@mindstudio-ai/remy 0.1.84 → 0.1.85

package/dist/headless.js

@@ -3147,6 +3147,16 @@ ${appSpec}
 
 // src/subagents/browserAutomation/index.ts
 var log6 = createLogger("browser-automation");
+var lockQueue = Promise.resolve();
+function acquireBrowserLock() {
+  let release;
+  const next = new Promise((res) => {
+    release = res;
+  });
+  const wait = lockQueue;
+  lockQueue = next;
+  return wait.then(() => release);
+}
 var browserAutomationTool = {
   clearable: true,
   definition: {
@@ -3167,99 +3177,104 @@ var browserAutomationTool = {
     if (!context) {
       return "Error: browser automation requires execution context (only available in headless mode)";
     }
+    const release = await acquireBrowserLock();
     try {
-      const status = await sidecarRequest(
-        "/browser-status",
-        {},
-        { timeout: 5e3 }
-      );
-      if (!status.connected) {
-        return "Error: the browser preview is not connected. The user needs to open the preview before browser tests can run.";
+      try {
+        const status = await sidecarRequest(
+          "/browser-status",
+          {},
+          { timeout: 5e3 }
+        );
+        if (!status.connected) {
+          return "Error: the browser preview is not connected. The user needs to open the preview before browser tests can run.";
+        }
+      } catch {
+        return "Error: could not check browser status. The dev environment may not be running.";
       }
-    } catch {
-      return "Error: could not check browser status. The dev environment may not be running.";
-    }
-    try {
-      await sidecarRequest("/reset-browser", {}, { timeout: 5e3 });
-    } catch {
-    }
-    const result = await runSubAgent({
-      system: getBrowserAutomationPrompt(),
-      task: input.task,
-      tools: BROWSER_TOOLS,
-      externalTools: BROWSER_EXTERNAL_TOOLS,
-      executeTool: async (name, _input, _toolCallId, onLog) => {
-        if (name === "screenshotFullPage") {
-          try {
-            return await captureAndAnalyzeScreenshot({
-              path: _input.path,
-              onLog
-            });
-          } catch (err) {
-            return `Error taking screenshot: ${err.message}`;
+      try {
+        await sidecarRequest("/reset-browser", {}, { timeout: 5e3 });
+      } catch {
+      }
+      const result = await runSubAgent({
+        system: getBrowserAutomationPrompt(),
+        task: input.task,
+        tools: BROWSER_TOOLS,
+        externalTools: BROWSER_EXTERNAL_TOOLS,
+        executeTool: async (name, _input, _toolCallId, onLog) => {
+          if (name === "screenshotFullPage") {
+            try {
+              return await captureAndAnalyzeScreenshot({
+                path: _input.path,
+                onLog
+              });
+            } catch (err) {
+              return `Error taking screenshot: ${err.message}`;
+            }
           }
-        }
-        return `Error: unknown local tool "${name}"`;
-      },
-      apiConfig: context.apiConfig,
-      model: context.model,
-      subAgentId: "browserAutomation",
-      signal: context.signal,
-      parentToolId: context.toolCallId,
-      requestId: context.requestId,
-      onEvent: context.onEvent,
-      resolveExternalTool: async (id, name, input2) => {
-        if (!context.resolveExternalTool) {
-          return "Error: no external tool resolver";
-        }
-        const result2 = await context.resolveExternalTool(id, name, input2);
-        if (name === "browserCommand") {
-          try {
-            const parsed = JSON.parse(result2);
-            const screenshotSteps = (parsed.steps || []).filter(
-              (s) => s.command === "screenshotViewport" && s.result?.url
-            );
-            if (screenshotSteps.length > 0) {
-              const batchInput = screenshotSteps.map((s) => ({
-                stepType: "analyzeImage",
-                step: {
-                  imageUrl: s.result.url,
-                  prompt: SCREENSHOT_ANALYSIS_PROMPT
-                }
-              }));
-              const batchResult = await runCli(
-                `mindstudio batch --no-meta ${JSON.stringify(JSON.stringify(batchInput))}`,
-                { timeout: 2e5 }
+          return `Error: unknown local tool "${name}"`;
+        },
+        apiConfig: context.apiConfig,
+        model: context.model,
+        subAgentId: "browserAutomation",
+        signal: context.signal,
+        parentToolId: context.toolCallId,
+        requestId: context.requestId,
+        onEvent: context.onEvent,
+        resolveExternalTool: async (id, name, input2) => {
+          if (!context.resolveExternalTool) {
+            return "Error: no external tool resolver";
+          }
+          const result2 = await context.resolveExternalTool(id, name, input2);
+          if (name === "browserCommand") {
+            try {
+              const parsed = JSON.parse(result2);
+              const screenshotSteps = (parsed.steps || []).filter(
+                (s) => s.command === "screenshotViewport" && s.result?.url
               );
-              try {
-                const analyses = JSON.parse(batchResult);
-                let ai = 0;
-                for (const step of parsed.steps) {
-                  if (step.command === "screenshotViewport" && step.result?.url && ai < analyses.length) {
-                    step.result.analysis = analyses[ai]?.output?.analysis || analyses[ai]?.output || "";
-                    ai++;
+              if (screenshotSteps.length > 0) {
+                const batchInput = screenshotSteps.map((s) => ({
+                  stepType: "analyzeImage",
+                  step: {
+                    imageUrl: s.result.url,
+                    prompt: SCREENSHOT_ANALYSIS_PROMPT
                   }
+                }));
+                const batchResult = await runCli(
+                  `mindstudio batch --no-meta ${JSON.stringify(JSON.stringify(batchInput))}`,
+                  { timeout: 2e5 }
+                );
+                try {
+                  const analyses = JSON.parse(batchResult);
+                  let ai = 0;
+                  for (const step of parsed.steps) {
+                    if (step.command === "screenshotViewport" && step.result?.url && ai < analyses.length) {
+                      step.result.analysis = analyses[ai]?.output?.analysis || analyses[ai]?.output || "";
+                      ai++;
+                    }
+                  }
+                } catch {
+                  log6.debug("Failed to parse batch analysis result", {
+                    batchResult
+                  });
                 }
-              } catch {
-                log6.debug("Failed to parse batch analysis result", {
-                  batchResult
-                });
+                return JSON.stringify(parsed);
               }
-              return JSON.stringify(parsed);
+            } catch {
             }
-          } catch {
           }
-        }
-        return result2;
-      },
-      toolRegistry: context.toolRegistry
-    });
-    try {
-      await sidecarRequest("/reset-browser", {}, { timeout: 5e3 });
-    } catch {
+          return result2;
+        },
+        toolRegistry: context.toolRegistry
+      });
+      try {
+        await sidecarRequest("/reset-browser", {}, { timeout: 5e3 });
+      } catch {
+      }
+      context.subAgentMessages?.set(context.toolCallId, result.messages);
+      return result.text;
+    } finally {
+      release();
     }
-    context.subAgentMessages?.set(context.toolCallId, result.messages);
-    return result.text;
   }
 };
 
@@ -4951,6 +4966,7 @@ var EXTERNAL_TOOLS = /* @__PURE__ */ new Set([
   "confirmDestructiveAction",
   "runScenario",
   "runMethod",
+  "queryDatabase",
   "browserCommand",
   "setProjectMetadata"
 ]);

package/dist/index.js

@@ -2931,7 +2931,16 @@ var init_prompt = __esm({
 });
 
 // src/subagents/browserAutomation/index.ts
-var log4, browserAutomationTool;
+function acquireBrowserLock() {
+  let release;
+  const next = new Promise((res) => {
+    release = res;
+  });
+  const wait = lockQueue;
+  lockQueue = next;
+  return wait.then(() => release);
+}
+var log4, lockQueue, browserAutomationTool;
 var init_browserAutomation = __esm({
   "src/subagents/browserAutomation/index.ts"() {
     "use strict";
@@ -2943,6 +2952,7 @@ var init_browserAutomation = __esm({
     init_runCli();
     init_logger();
     log4 = createLogger("browser-automation");
+    lockQueue = Promise.resolve();
     browserAutomationTool = {
       clearable: true,
       definition: {
@@ -2963,99 +2973,104 @@ var init_browserAutomation = __esm({
         if (!context) {
           return "Error: browser automation requires execution context (only available in headless mode)";
         }
+        const release = await acquireBrowserLock();
         try {
-          const status = await sidecarRequest(
-            "/browser-status",
-            {},
-            { timeout: 5e3 }
-          );
-          if (!status.connected) {
-            return "Error: the browser preview is not connected. The user needs to open the preview before browser tests can run.";
+          try {
+            const status = await sidecarRequest(
+              "/browser-status",
+              {},
+              { timeout: 5e3 }
+            );
+            if (!status.connected) {
+              return "Error: the browser preview is not connected. The user needs to open the preview before browser tests can run.";
+            }
+          } catch {
+            return "Error: could not check browser status. The dev environment may not be running.";
           }
-        } catch {
-          return "Error: could not check browser status. The dev environment may not be running.";
-        }
-        try {
-          await sidecarRequest("/reset-browser", {}, { timeout: 5e3 });
-        } catch {
-        }
-        const result = await runSubAgent({
-          system: getBrowserAutomationPrompt(),
-          task: input.task,
-          tools: BROWSER_TOOLS,
-          externalTools: BROWSER_EXTERNAL_TOOLS,
-          executeTool: async (name, _input, _toolCallId, onLog) => {
-            if (name === "screenshotFullPage") {
-              try {
-                return await captureAndAnalyzeScreenshot({
-                  path: _input.path,
-                  onLog
-                });
-              } catch (err) {
-                return `Error taking screenshot: ${err.message}`;
+          try {
+            await sidecarRequest("/reset-browser", {}, { timeout: 5e3 });
+          } catch {
+          }
+          const result = await runSubAgent({
+            system: getBrowserAutomationPrompt(),
+            task: input.task,
+            tools: BROWSER_TOOLS,
+            externalTools: BROWSER_EXTERNAL_TOOLS,
+            executeTool: async (name, _input, _toolCallId, onLog) => {
+              if (name === "screenshotFullPage") {
+                try {
+                  return await captureAndAnalyzeScreenshot({
+                    path: _input.path,
+                    onLog
+                  });
+                } catch (err) {
+                  return `Error taking screenshot: ${err.message}`;
+                }
               }
-            }
-            return `Error: unknown local tool "${name}"`;
-          },
-          apiConfig: context.apiConfig,
-          model: context.model,
-          subAgentId: "browserAutomation",
-          signal: context.signal,
-          parentToolId: context.toolCallId,
-          requestId: context.requestId,
-          onEvent: context.onEvent,
-          resolveExternalTool: async (id, name, input2) => {
-            if (!context.resolveExternalTool) {
-              return "Error: no external tool resolver";
-            }
-            const result2 = await context.resolveExternalTool(id, name, input2);
-            if (name === "browserCommand") {
-              try {
-                const parsed = JSON.parse(result2);
-                const screenshotSteps = (parsed.steps || []).filter(
-                  (s) => s.command === "screenshotViewport" && s.result?.url
-                );
-                if (screenshotSteps.length > 0) {
-                  const batchInput = screenshotSteps.map((s) => ({
-                    stepType: "analyzeImage",
-                    step: {
-                      imageUrl: s.result.url,
-                      prompt: SCREENSHOT_ANALYSIS_PROMPT
-                    }
-                  }));
-                  const batchResult = await runCli(
-                    `mindstudio batch --no-meta ${JSON.stringify(JSON.stringify(batchInput))}`,
-                    { timeout: 2e5 }
+              return `Error: unknown local tool "${name}"`;
+            },
+            apiConfig: context.apiConfig,
+            model: context.model,
+            subAgentId: "browserAutomation",
+            signal: context.signal,
+            parentToolId: context.toolCallId,
+            requestId: context.requestId,
+            onEvent: context.onEvent,
+            resolveExternalTool: async (id, name, input2) => {
+              if (!context.resolveExternalTool) {
+                return "Error: no external tool resolver";
+              }
+              const result2 = await context.resolveExternalTool(id, name, input2);
+              if (name === "browserCommand") {
+                try {
+                  const parsed = JSON.parse(result2);
+                  const screenshotSteps = (parsed.steps || []).filter(
+                    (s) => s.command === "screenshotViewport" && s.result?.url
                   );
-                  try {
-                    const analyses = JSON.parse(batchResult);
-                    let ai = 0;
-                    for (const step of parsed.steps) {
-                      if (step.command === "screenshotViewport" && step.result?.url && ai < analyses.length) {
-                        step.result.analysis = analyses[ai]?.output?.analysis || analyses[ai]?.output || "";
-                        ai++;
+                  if (screenshotSteps.length > 0) {
+                    const batchInput = screenshotSteps.map((s) => ({
+                      stepType: "analyzeImage",
+                      step: {
+                        imageUrl: s.result.url,
+                        prompt: SCREENSHOT_ANALYSIS_PROMPT
+                      }
+                    }));
+                    const batchResult = await runCli(
+                      `mindstudio batch --no-meta ${JSON.stringify(JSON.stringify(batchInput))}`,
+                      { timeout: 2e5 }
+                    );
+                    try {
+                      const analyses = JSON.parse(batchResult);
+                      let ai = 0;
+                      for (const step of parsed.steps) {
+                        if (step.command === "screenshotViewport" && step.result?.url && ai < analyses.length) {
+                          step.result.analysis = analyses[ai]?.output?.analysis || analyses[ai]?.output || "";
+                          ai++;
+                        }
                       }
+                    } catch {
+                      log4.debug("Failed to parse batch analysis result", {
+                        batchResult
+                      });
                     }
-                  } catch {
-                    log4.debug("Failed to parse batch analysis result", {
-                      batchResult
-                    });
+                    return JSON.stringify(parsed);
                   }
-                  return JSON.stringify(parsed);
+                } catch {
                 }
-              } catch {
               }
-            }
-            return result2;
-          },
-          toolRegistry: context.toolRegistry
-        });
-        try {
-          await sidecarRequest("/reset-browser", {}, { timeout: 5e3 });
-        } catch {
+              return result2;
+            },
+            toolRegistry: context.toolRegistry
+          });
+          try {
+            await sidecarRequest("/reset-browser", {}, { timeout: 5e3 });
+          } catch {
+          }
+          context.subAgentMessages?.set(context.toolCallId, result.messages);
+          return result.text;
+        } finally {
+          release();
         }
-        context.subAgentMessages?.set(context.toolCallId, result.messages);
-        return result.text;
       }
     };
   }
@@ -5494,6 +5509,7 @@ var init_agent = __esm({
       "confirmDestructiveAction",
       "runScenario",
       "runMethod",
+      "queryDatabase",
       "browserCommand",
       "setProjectMetadata"
     ]);

package/dist/prompt/compiled/dev-and-deploy.md

@@ -19,7 +19,7 @@ The dev session gets its own database — a snapshot of the live database at ses
 - **Truncate** — keep the schema, delete all row data (used by scenarios for a clean canvas)
 - **Schema sync** — add a field to a table interface and it's immediately available in dev
 
-The dev database is disposable. Experiment freely — there's no risk of breaking anything.
+The dev database is disposable. Experiment freely — there's no risk of breaking anything. Just be considerate that the user may have created their own data (user rows or other data) while testing, and it might be frustrating for them to have it wiped.
 
 ### Debugging
 

package/dist/prompt/compiled/scenarios.md

@@ -96,12 +96,14 @@ Shared setup code can go in `dist/methods/.scenarios/_helpers/`.
 ## How Scenarios Run
 
 When a scenario runs, the platform:
-1. **Truncates** all tables (deletes all rows, preserves schema)
+1. **Truncates** all tables (deletes all rows, preserves schema - unless skipTruncate is true)
 2. **Executes** the seed function (your `db.push()` calls populate the clean database)
 3. **Impersonates** the roles from the scenario's `roles` field (the app renders from that user's perspective)
 
 This is deterministic — same scenario always produces the same state.
 
+Scenarios are useful for seeding initial app state after build for testing, as well as to give the user a first impression of an app that is already filled with data and looks and feels usable. The user can choose to run further scenarios after initial build by clicking the Scenarios tab and selecting a scenario to run.
+
 ## Scenario Data
 
 Align scenario data to the vibe of the app - construct data that feels like it fits.

package/dist/prompt/static/coding.md

@@ -9,7 +9,7 @@
 ### Verification
 Run `lspDiagnostics` after every turn where you have edited code in any meaningful way. You don't need to run it for things like changing copy or CSS colors, but you should run it after any structural changes to code. It catches syntax errors, broken imports, and type mismatches instantly. After a big build or significant changes, also do a lightweight runtime check to catch the things static analysis misses (schema mismatches, missing imports, bad queries):
 
-- Seed test data with `runScenario`, then spot-check the primary method or two with `runMethod`. The dev database is a disposable snapshot, so don't worry about being destructive.
+- Spot-check methods with `runMethod`. The dev database is a disposable snapshot that will have been seeded with scenario data, so don't worry about being destructive.
 - For frontend work, take a single `screenshot` to confirm the main view renders correctly or look at the browser log for any console errors in the user's preview.
 - Use `runAutomatedBrowserTest` to verify an interactive flow that you can't confirm from a screenshot, or when the user reports something broken that you can't identify from code alone.
 
@@ -38,8 +38,5 @@ For any work involving AI models, external actions (web scraping, email, SMS), o
 ### State Management
 - Calls to methods introduce latency. When building web frontends that load data from methods, consider front-loading as much data as you can in a single API request - e.g., when possible, load a large data object into a central store and use that to render sub-screens in an app, rather than an API call on every screen.
 
-### Build Notes
-For complex builds that span many files — especially an initial buildout from a spec — write a `.remy-notes.md` scratchpad in the project root. Use it to record decisions, keep a checklist of tasks, and reference data you'll need across multiple tool calls: design tokens, color values, typography specs, image URLs, what's been built so far, what's left. Read it back instead of restating everything in your messages. Delete it when the build is done. Don't use this for small changes or single-file edits.
-
 ### Dependencies
 Before installing a package you haven't used in this project, do a quick web search to confirm it's still the best option. The JavaScript ecosystem moves fast — the package you remember from training may have been superseded by something smaller, faster, or better maintained. A 10-second search beats debugging a deprecated library.

package/dist/prompt/static/instructions.md

@@ -15,6 +15,9 @@
 - After two failed attempts at the same approach, tell the user what's going wrong.
 - Pushing to main branch will trigger a deploy. The user presses the publish button in the interface to request publishing.
 
+### Build Notes
+For complex tasks — especially an initial buildout from a spec or making multiple changes in a single turn — write a `.remy-notes.md` scratchpad in the project root. Use it to record decisions, keep a checklist of tasks, and reference data you'll need across multiple tool calls: design tokens, color values, typography specs, image URLs, what's been built so far, what's left. Read it back instead of restating everything in your messages. Delete it when your work is done.
+
 ## Communication
 The user can already see your tool calls, so most of your work is visible without narration. Focus text output on three things:
 - **Decisions that need input.** Questions, tradeoffs, ambiguity that blocks progress.

package/dist/subagents/codeSanityCheck/prompt.md

@@ -35,6 +35,10 @@ These are recurring mistakes the coding agent makes. If you see the conditions f
 
 - **CSS Module animation scoping.** If the agent defines `@keyframes` in a global CSS file but references the animation name from a CSS Module, the animation will silently fail. CSS Modules scope animation names, so a keyframe defined globally can't be found by a scoped class. The fix: define keyframes in the same CSS Module that uses them, or use `:global()` to escape the scoping.
 
+- **Too many granular API calls.** These apps are MVPs with small datasets. If the plan has separate method calls for every screen or sub-view (load profile, then load posts, then load post detail, then load comments), flag it. Favor fewer, fatter requests — a profile page that loads posts with full content means tapping a post is instant. A feed that includes comment previews and like state means the detail view renders from memory. Over-fetching at this scale is almost always the right call — users notice instant transitions, they don't notice a slightly larger payload.
+
+- **Wouter is not React Router.** The agent defaults to React Router patterns which silently break in wouter. Key differences: no `useNavigate()` (use `const [, setLocation] = useLocation()`), no `navigate(-1)` for back (use `window.history.back()`), no `element` prop on Route (use `component={Foo}` or children), no `<Routes>` (use `<Switch>` — without it all matching routes render simultaneously), no `<Navigate>` (use `<Redirect>`), no `<Outlet>` for nested routes (use `nest` prop on Route), and no `useSearchParams()` from react-router (wouter has its own version with a different setter API). If you see any of these React Router patterns in a wouter project, flag it.
+
 ## When to stay quiet
 
 Nits, style preferences, missing edge cases, things the agent will figure out as it goes, patterns that are "not ideal but fine," minor code smells. Let them slide. The agent is busy.

package/dist/subagents/designExpert/prompts/ui-patterns.md

@@ -32,11 +32,13 @@ Pay close attention to text streaming when the AI replies - it should feel natur
 
 ### Wireframes
 
-When a pattern or interaction is hard to convey in words alone — an animation sequence, a swipe gesture, a layout grid — you can include a small interactive wireframe to demonstrate it. Use a markdown code fence with `wireframe` as the type. Start with a YAML frontmatter block (`name` and `description`) to identify the component, then the self-contained HTML+CSS prototype.
+When a pattern or interaction is hard to convey in words alone — a core component, an animation sequence, a swipe gesture, a layout grid — you can include a small interactive wireframe to demonstrate it. Use a markdown code fence with `wireframe` as the type. Start with a YAML frontmatter block (`name` and `description`) to identify the component, then the self-contained HTML+CSS prototype.
 
-Wireframes replace the ASCII art and code-block diagrams you might otherwise reach for when trying to show a layout or interaction. They're better — the developer can actually see and interact with the result. Like those diagrams, they isolate one small piece: a single card component, a button animation, a transition, a grid layout. Each wireframe should be around 60-80 lines of HTML+CSS — if you're past 100 lines, you're building too much. These are not screens, flows, or multi-step prototypes. They render in a small iframe and should look complete at that scale. Most of your communication should be in words - wireframes are simply another tool when you need them. Never build out full screens or pages in wireframes, even if you are asked to - this is critically important.
+Use wireframes instead of ASCII art and code-block diagrams you might otherwise reach for when trying to show a layout or interaction. Wireframes are better because the developer can actually see and interact with the result. Like those diagrams, they isolate one small piece: a single card component, a button animation, a transition, a grid layout. Each wireframe should be around 60-80 lines of HTML+CSS — if you're past 100 lines, you're building too much. These are not screens, flows, or multi-step prototypes. They render in a small iframe and should look complete at that scale. Most of your communication should be in words - wireframes are simply another tool when you need them. Never build out full screens or pages in wireframes, even if you are asked to - this is critically important.
 
-The wireframe code will be rendered in a transparent iframe. Don't fill the viewport or add a background color to the body. Place the component at a natural size in a card with a background color that is centered vertically and horizontally in the viewport. Keep the component tight and self-contained. The iframe is for the component only — no annotations, labels, or explanatory text inside it. Put your notes and implementation guidance in the markdown around the wireframe. Wireframes can be interactive and are especially useful for demonstrating states, animations, effects, and transitions. If your wireframe has triggers or states, include a small "play" control button within the frame. No images - these are functional prototypes meant to demonstrate feel and behavior, not visual comps.
+Remember, never use ascii art or code-block diagrams to describe layouts - always use wireframes.
+
+The wireframe code will be rendered in a transparent iframe. Don't fill the viewport or add a background color to the body. Place the component at a natural size in a card with a background color that is centered vertically and horizontally in the viewport. Keep the component tight and self-contained. The iframe is for the component only — no annotations, labels, or explanatory text inside it. Put your notes and implementation guidance in the markdown around the wireframe. Wireframes can be interactive and are especially useful for demonstrating states, animations, effects, and transitions. If your wireframe has triggers or states, include a small "play" control button within the frame (make sure to allow reply/reset for all interactivity). No images - these are functional prototypes meant to demonstrate feel and behavior, not visual comps.
 
 ```wireframe
 ---

package/package.json

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