@mindstudio-ai/remy 0.1.89 → 0.1.91

package/dist/automatedActions/buildFromInitialSpec.md

@@ -10,7 +10,7 @@ Think about your approach and then get a quick sanity check from `codeSanityChec
 
 If you are building a web frontend, consult `visualDesignExpert` for guidance and ideas on specific component design, UI patterns, and interactions - it has access to a deep repository of design inspiration and will be able to give you great ideas to work with while building. Don't ask it to design full screens - focus on specific components, moments, and concepts where its ideas can be additive and transformative, you already have the basic design and layout guidance from the spec.
 
-Then, build everything in one turn: methods, tables, interfaces, manifest updates, and scenarios, using the spec as the master plan. Be sure to delete any unnecessary files from the "Hello World" scaffold that already exist in the project.
+Then, build everything in one turn: methods, tables, interfaces, manifest updates, and scenarios, using the spec as the master plan. Be sure to delete any unnecessary files from the "Hello World" scaffold that already exist in the project - don't forget to update the page title on index.html too.
 
 When code generation is complete, verify your work: 
 - First, run use `runScenario` to seed test data, then use `runMethod` to confirm a method works 

package/dist/headless.js

@@ -2007,7 +2007,7 @@ ${unifiedDiff(input.path, content, updated)}`;
 };
 
 // src/tools/code/bash.ts
-import { exec } from "child_process";
+import { spawn as spawn2 } from "child_process";
 var DEFAULT_TIMEOUT_MS = 12e4;
 var DEFAULT_MAX_LINES3 = 500;
 var bashTool = {
@@ -2038,51 +2038,59 @@ var bashTool = {
       required: ["command"]
     }
   },
-  async execute(input) {
+  async execute(input, context) {
     const maxLines = input.maxLines === 0 ? Infinity : input.maxLines || DEFAULT_MAX_LINES3;
     const timeoutMs = input.timeout ? input.timeout * 1e3 : DEFAULT_TIMEOUT_MS;
     return new Promise((resolve) => {
-      exec(
-        input.command,
-        {
-          timeout: timeoutMs,
-          maxBuffer: 2 * 1024 * 1024,
-          ...input.cwd ? { cwd: input.cwd } : {},
-          env: { ...process.env, FORCE_COLOR: "1" }
-        },
-        (err, stdout, stderr) => {
-          let result = "";
-          if (stdout) {
-            result += stdout;
-          }
-          if (stderr) {
-            result += (result ? "\n" : "") + stderr;
-          }
-          if (err && !stdout && !stderr) {
-            result = `Error: ${err.message}`;
-          }
-          if (!result) {
+      const child = spawn2("sh", ["-c", input.command], {
+        cwd: input.cwd || void 0,
+        env: { ...process.env, FORCE_COLOR: "1" }
+      });
+      let output = "";
+      child.stdout.on("data", (chunk) => {
+        const text = chunk.toString();
+        output += text;
+        context?.onLog?.(text);
+      });
+      child.stderr.on("data", (chunk) => {
+        const text = chunk.toString();
+        output += text;
+        context?.onLog?.(text);
+      });
+      const timer = setTimeout(() => {
+        child.kill("SIGTERM");
+      }, timeoutMs);
+      child.on("close", (code) => {
+        clearTimeout(timer);
+        if (!output) {
+          if (code && code !== 0) {
+            resolve(`Error: process exited with code ${code}`);
+          } else {
             resolve("(no output)");
-            return;
           }
-          const lines = result.split("\n");
-          if (lines.length > maxLines) {
-            resolve(
-              lines.slice(0, maxLines).join("\n") + `
+          return;
+        }
+        const lines = output.split("\n");
+        if (lines.length > maxLines) {
+          resolve(
+            lines.slice(0, maxLines).join("\n") + `
 
 (truncated at ${maxLines} lines of ${lines.length} total \u2014 increase maxLines to see more)`
-            );
-          } else {
-            resolve(result);
-          }
+          );
+        } else {
+          resolve(output);
         }
-      );
+      });
+      child.on("error", (err) => {
+        clearTimeout(timer);
+        resolve(`Error: ${err.message}`);
+      });
     });
   }
 };
 
 // src/tools/code/grep.ts
-import { exec as exec2 } from "child_process";
+import { exec } from "child_process";
 var DEFAULT_MAX = 50;
 function formatResults(stdout, max) {
   const lines = stdout.trim().split("\n");
@@ -2130,12 +2138,12 @@ var grepTool = {
     const rgCmd = `rg -n --no-heading --max-count=${max}${globFlag} '${escaped}' ${searchPath}`;
     const grepCmd = `grep -rn --max-count=${max} '${escaped}' ${searchPath} --include='*.ts' --include='*.tsx' --include='*.js' --include='*.json' --include='*.md'`;
     return new Promise((resolve) => {
-      exec2(rgCmd, { maxBuffer: 512 * 1024 }, (err, stdout) => {
+      exec(rgCmd, { maxBuffer: 512 * 1024 }, (err, stdout) => {
         if (stdout?.trim()) {
           resolve(formatResults(stdout, max));
           return;
         }
-        exec2(grepCmd, { maxBuffer: 512 * 1024 }, (_err, grepStdout) => {
+        exec(grepCmd, { maxBuffer: 512 * 1024 }, (_err, grepStdout) => {
           if (grepStdout?.trim()) {
             resolve(formatResults(grepStdout, max));
           } else {

package/dist/index.js

@@ -1573,7 +1573,7 @@ ${unifiedDiff(input.path, content, updated)}`;
 });
 
 // src/tools/code/bash.ts
-import { exec } from "child_process";
+import { spawn as spawn2 } from "child_process";
 var DEFAULT_TIMEOUT_MS, DEFAULT_MAX_LINES3, bashTool;
 var init_bash = __esm({
   "src/tools/code/bash.ts"() {
@@ -1608,45 +1608,53 @@ var init_bash = __esm({
           required: ["command"]
         }
       },
-      async execute(input) {
+      async execute(input, context) {
         const maxLines = input.maxLines === 0 ? Infinity : input.maxLines || DEFAULT_MAX_LINES3;
         const timeoutMs = input.timeout ? input.timeout * 1e3 : DEFAULT_TIMEOUT_MS;
         return new Promise((resolve) => {
-          exec(
-            input.command,
-            {
-              timeout: timeoutMs,
-              maxBuffer: 2 * 1024 * 1024,
-              ...input.cwd ? { cwd: input.cwd } : {},
-              env: { ...process.env, FORCE_COLOR: "1" }
-            },
-            (err, stdout, stderr) => {
-              let result = "";
-              if (stdout) {
-                result += stdout;
-              }
-              if (stderr) {
-                result += (result ? "\n" : "") + stderr;
-              }
-              if (err && !stdout && !stderr) {
-                result = `Error: ${err.message}`;
-              }
-              if (!result) {
+          const child = spawn2("sh", ["-c", input.command], {
+            cwd: input.cwd || void 0,
+            env: { ...process.env, FORCE_COLOR: "1" }
+          });
+          let output = "";
+          child.stdout.on("data", (chunk) => {
+            const text = chunk.toString();
+            output += text;
+            context?.onLog?.(text);
+          });
+          child.stderr.on("data", (chunk) => {
+            const text = chunk.toString();
+            output += text;
+            context?.onLog?.(text);
+          });
+          const timer = setTimeout(() => {
+            child.kill("SIGTERM");
+          }, timeoutMs);
+          child.on("close", (code) => {
+            clearTimeout(timer);
+            if (!output) {
+              if (code && code !== 0) {
+                resolve(`Error: process exited with code ${code}`);
+              } else {
                 resolve("(no output)");
-                return;
               }
-              const lines = result.split("\n");
-              if (lines.length > maxLines) {
-                resolve(
-                  lines.slice(0, maxLines).join("\n") + `
+              return;
+            }
+            const lines = output.split("\n");
+            if (lines.length > maxLines) {
+              resolve(
+                lines.slice(0, maxLines).join("\n") + `
 
 (truncated at ${maxLines} lines of ${lines.length} total \u2014 increase maxLines to see more)`
-                );
-              } else {
-                resolve(result);
-              }
+              );
+            } else {
+              resolve(output);
             }
-          );
+          });
+          child.on("error", (err) => {
+            clearTimeout(timer);
+            resolve(`Error: ${err.message}`);
+          });
         });
       }
     };
@@ -1654,7 +1662,7 @@ var init_bash = __esm({
 });
 
 // src/tools/code/grep.ts
-import { exec as exec2 } from "child_process";
+import { exec } from "child_process";
 function formatResults(stdout, max) {
   const lines = stdout.trim().split("\n");
   let result = lines.join("\n");
@@ -1706,12 +1714,12 @@ var init_grep = __esm({
         const rgCmd = `rg -n --no-heading --max-count=${max}${globFlag} '${escaped}' ${searchPath}`;
         const grepCmd = `grep -rn --max-count=${max} '${escaped}' ${searchPath} --include='*.ts' --include='*.tsx' --include='*.js' --include='*.json' --include='*.md'`;
         return new Promise((resolve) => {
-          exec2(rgCmd, { maxBuffer: 512 * 1024 }, (err, stdout) => {
+          exec(rgCmd, { maxBuffer: 512 * 1024 }, (err, stdout) => {
             if (stdout?.trim()) {
               resolve(formatResults(stdout, max));
               return;
             }
-            exec2(grepCmd, { maxBuffer: 512 * 1024 }, (_err, grepStdout) => {
+            exec(grepCmd, { maxBuffer: 512 * 1024 }, (_err, grepStdout) => {
               if (grepStdout?.trim()) {
                 resolve(formatResults(grepStdout, max));
               } else {

package/dist/prompt/compiled/design.md

@@ -85,22 +85,29 @@ The UI should feel instant. Never make the user wait for a server round-trip to
 Handle errors gracefully. You don't need to design for every error case, but if remote API requests fail, make sure to show them nicely in a toast or some other appropriate view with a human-friendly label - don't just drop "Error 500 XYZ" inline in a form.
 
 ## Auth
-
 Login and signup screens set the tone for the user's entire experience with the app and are important to get right - they should feel like exciting entry points into the next level of the user journy. A janky login form with misaligned inputs and no feedback dminishes excitement and undermines trust before the user even gets in.
 
 Authentication moments must feel natural and intuitive - they should not feel jarring or surprising. Take care to integrate them into the entire experience when building. MindStudio apps support SMS code verification, email verification, or both, depending on how the app is configured.
 
-**Verification code input:** The 6-digit code entry is the critical moment. Prefer to design it as individual digit boxes (not a single text input), with auto-advance between digits, auto-submit on paste, and clear visual feedback. The boxes should be large enough to tap easily on mobile. Show a subtle animation on successful verification. Error states should be inline and immediate, not a separate alert.
+### Rules for building auth screens
+
+Consult the `visualDesignExpert` to help you work through authentication at a high level. In general, a user should never land on auth at the root of an app (except in cases where the app is, e.g., an internal tool or some other protected experience). Users should be able to explore public resources, or at least encounter some kind of landing/introduction moment, before they get hit with a signup/login screen. Make auth feel like a natural moment in the user's journey.
+
+**Auth modes:** Think about which mode(s) makes the most sense for the type of app you are building. Consumer apps likely to be used on mobile should probably tend toward SMS auth as the default - business apps used on desktop make more sense to use email verification - or allow both, there's no harm in giving the user choice!
 
-**The send/resend flow:** After the user enters their email or phone and taps "Send code," show clear confirmation that the code was sent ("Check your email" with the address displayed). Include a resend option with a cooldown timer (e.g., "Resend in 30s"). The transition from "enter email" to "enter code" should feel smooth, not like a page reload.
+**Verification code input:** The 6-digit code entry is the critical moment. Prefer to design it as individual digit boxes (not a single text input), with auto-advance between digits, a beautiful animation and auto-submit on paste, and clear visual feedback. The boxes should be large enough to tap easily on mobile. Show a subtle animation on successful verification. Error states should be inline and immediate, not a separate alert. Make sure there is no layout shift when loading in the success/error states.
 
-**The overall login page:** This is a branding moment. Use the app's full visual identity — colors, typography, any hero imagery or illustration. A centered card on a branded background is a classic pattern. Don't make it look like a generic SaaS login template. The login page should feel like it belongs to this specific app.
+**The send/resend flow:** After the user enters their email or phone and taps "Send code," show clear confirmation that the code was sent ("Check your email" with the address displayed). Include a resend option with a cooldown timer (e.g., "Resend in 30s"). The transition from "enter email/phone" to "enter code" should feel smooth, not like a page reload. Always make sure the user can cancel and exit the flow (e.g., they had a typo in their email, or remembered they used a different email to sign up).
 
-**Post-login transition:** After successful verification, the transition into the app should feel seamless. Avoid a blank loading screen — if data needs to load, show the app shell with skeleton states.
+**The overall login page:** This is a branding moment. Use the app's full visual identity — colors, typography, any logos, hero imagery, or illustration. A centered card on a branded background is a classic pattern. Don't make it look like a generic SaaS login template. The login page must feel like it belongs to this specific app. Consult the `visualDesignExpert` for additional guidance.
+
+**Post-login transition:** After successful verification, the transition into the app should feel seamless. Avoid a blank loading screen — if data needs to load, show the app shell with skeleton states. Always make sure the user has a way of logging out.
 
 ## FTUE
 
-All interactive apps must be intuitive and easy to use. Form elements must be well-labelled. Complex interfaces should have descriptions or tooltips when helpful. Complex apps benefit from a beautiful simple onboarding modal on first use or a simple click tour. Mobile apps need a beautiful welcome screen sequence that orients the user to the app. Ask the visualDesignExpert for advice here. Even if the app is intuitive and easy to use, users showing up for the first time might still be overwhelmed or confused, and we have an opportunity to set expectations, provide context, and make the user confident as they use our product. Don't neglect this.
+All interactive apps must be intuitive and easy to use. Form elements must be well-labelled. Complex interfaces should have descriptions or tooltips when helpful. Complex apps benefit from a beautiful simple onboarding modal on first use or a simple click tour. Mobile apps need a beautiful welcome screen sequence that orients the user to the app. Ask the `visualDesignExpert` for advice here. 
+
+Even if the app is intuitive and easy to use, users showing up for the first time might still be overwhelmed or confused, and we have an opportunity to set expectations, provide context, and make the user confident as they use our product. Don't neglect this.
 
 ## What to Actively Avoid At All Costs
 

package/dist/prompt/static/instructions.md

@@ -13,6 +13,7 @@
 - Work with what you already know. If you've read a file in this session, use what you learned rather than reading it again. If a subagent already researched something, use its findings. Every tool call costs time; prefer acting on information you have over re-gathering it.
 - When multiple tool calls are independent, make them all in a single turn. Reading three files, writing two methods, or running a scenario while taking a screenshot: batch them instead of doing one per turn.
 - After two failed attempts at the same approach, tell the user what's going wrong.
+- Never estimate how long something will take. Just do it.
 - Pushing to main branch will trigger a deploy. The user presses the publish button in the interface to request publishing.
 
 ### Build Notes

package/dist/subagents/codeSanityCheck/prompt.md

@@ -28,6 +28,7 @@ These are things we already know about and have decided to accept:
 - Preferences:
   - use [wouter](https://github.com/molefrog/wouter) for React routing instead of reaching for react-router
   - uploading user files should mostly always happen via @mindstudio-ai/interface's platform.uploadFile() - it does the whole signed S3 upload dance and returns a permanent CDN url, including query-string-resizable images, videos + auto-thumbnails, etc.
+  - for static prerendering of Vite + React sites, roll your own with a post-build `renderToString` script — do not use `vite-prerender-plugin` (it bundles the prerender script as a client chunk, adding ~800KB to the user-facing bundle with no way to prevent it)
 
 ### Common pitfalls (always flag these)
 
@@ -43,6 +44,8 @@ These are recurring mistakes the coding agent makes. If you see the conditions f
 
 - **iOS mobile web touch/gesture handling.** If the plan involves horizontal swipe elements (carousels, image viewers, sliders) inside a scrolling page, flag these requirements: detect swipe direction by tracking both X and Y delta on touchmove, lock to horizontal after 8-10px of movement, only `preventDefault()` when locked horizontal, set `touch-action: pan-y` on the swipe container. On any draggable/swipeable container: `user-select: none`, `-webkit-user-select: none`, `-webkit-touch-callout: none`, `draggable="false"` on images, `pointer-events: none` on images inside the swipe track. Also: `* { -webkit-tap-highlight-color: transparent }` removes the gray flash Safari adds to tappable elements — one line, global fix, should be in every project's reset CSS.
 
+- **tsx outside Vite needs TSX_TSCONFIG_PATH.** If the plan runs a script via `tsx` that imports React components (e.g., a prerender script), it needs `TSX_TSCONFIG_PATH=tsconfig.app.json` so tsx picks up `"jsx": "react-jsx"`. Without it you get `ReferenceError: React is not defined`.
+
 - **Image preloading for detail views.** If the plan has a grid/list of thumbnails that link to detail views with full-size images, flag it if there's no preloading strategy. The fix: preload full-size images in the background (`new Image().src = url`) so they're in the browser cache by the time the user taps. This makes transitions feel instant.
 
 ## When to stay quiet

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mindstudio-ai/remy",
-  "version": "0.1.89",
+  "version": "0.1.91",
   "description": "MindStudio coding agent",
   "repository": {
     "type": "git",