@mindstudio-ai/remy 0.1.175 → 0.1.177

package/dist/prompt/compiled/interfaces.md

@@ -92,6 +92,27 @@ The project uses `"jsx": "react-jsx"` (automatic JSX transform) — do not `impo
 
 On deploy, the platform runs `npm install && npm run build` in the web directory and hosts the output on CDN.
 
+#### Error Handling and Analytics
+
+The SDK automatically reports uncaught errors, unhandled promise rejections, and pageviews to a per-app dashboard the owner gets for free. No setup required. The analytics dashboard covers visits, unique visitors, top pages, referrers, UTM breakdowns, country-level geo, device/browser/OS, new vs returning, and live online count.
+
+What this means for code you write:
+
+- **Don't install Sentry, Google Analytics, Plausible, Mixpanel, or similar unless the user specifically asks.** The platform dashboard already covers lay-person observability and analytics.
+- **Caught errors are yours to handle. Uncaught errors are captured automatically** If you `try/catch`, show a toast or render a fallback. Let unexpected errors bubble; a React error boundary can render a fallback while the SDK reports the error.
+- **For custom events**, use `analytics.track(name, props?)`. Props must be flat primitives (`string | number | boolean`); nested objects, arrays, `null`, and `undefined` are stripped. Server caps name ≤200 chars, ≤10 props, ≤50-char keys, ≤500-char values.
+
+```ts
+import { analytics } from '@mindstudio-ai/interface';
+
+analytics.track('vendor_submitted', { vendorType: 'restaurant' });
+analytics.track('checkout_completed', { itemCount: 3, total: 47.99 });
+```
+
+Analytics is **cookie-banner-free by design**: per-app scoping, IP discarded after geo lookup, country-level only, query strings server-scrubbed except for a UTM whitelist (`utm_*`, `ref`, `source`, `gclid`, `fbclid`, `msclkid`), no fingerprinting, no third-party scripts. If a user asks about GDPR cookie consent for analytics, you can explain why it is not needed.
+
+Disabling telemetry is a per-app dashboard setting (platform toggle, not code). Point users there if they ask.
+
 ## API Interface
 
 REST endpoints for external consumers — other services, mobile apps, integrations. This is separate from the web frontend's internal RPC (`@mindstudio-ai/interface` calls `/_/methods` directly and does not use the API interface). The API interface lives at `/_/api/` and exposes only the methods you choose to route.
@@ -323,19 +344,43 @@ Accepts any HTTP method. The method receives `{ method, headers, query, body }`
 
 ## Email
 
-Inbound email triggers.
+Inbound email triggers. An app can register one inbound address that routes all inbound emails to one method.
 
 ### Config (`interface.json`)
 
 ```json
 {
   "email": {
-    "method": "handle-inbound-email"
+    "method": "handle-inbound-email",
+    "approvedSenders": ["billing@vendor.com", "*@trusted-partner.com"]
   }
 }
 ```
 
-Register a custom address (e.g., `invoices@mindstudio-hooks.com`) via the platform. Inbound emails invoke the specified method with the email content as input.
+`approvedSenders` is optional. When set, only senders matching an exact address or `*@domain.com` wildcard reach the method; everything else is rejected by the platform with `400 invalid_sender` before the method runs.
+
+Address pattern: `{custom-name}@mindstudio-hooks.com`.
+
+### Input shape
+
+```ts
+{
+  to: string;            // resolved from the SMTP envelope
+  from: string;          // bare address, extracted from "Name <a@b>" form
+  subject: string;       // 'No Subject' if missing
+  message: string;       // plain text body; 'No Body' if neither text nor html was sent
+  html: string;          // HTML body, or '' when text-only
+  attachments: string[]; // CDN URLs — already uploaded by the platform
+}
+```
+
+### Attachments
+
+`attachments[]` is an array of CDN URLs — the platform has already received and uploaded the files. Fetch them server-side via the URL when you need the bytes; pass them through as URLs to UI or downstream services.
+
+### Auth
+
+Methods invoked through this interface run with `auth.roles: ['system']` (see the system-roles section above). They have no user session and can't impersonate. Use `auth.requireRole('system')` to gate methods that should only be reachable via email.
 
 ## MCP (Model Context Protocol)
 

package/dist/prompt/static/coding.md

@@ -17,7 +17,6 @@ Aim for confidence that the core happy paths work. If the 80% case is solid, the
 When making mechanical edits as part of iterating with the user (e.g., moving elements, changing labels, small redesigns and refactors), don't screenshot to confirm, simply trust your code. Re-screenshot only when changes are structural enough that the visual outcome is genuinely uncertain (new layout, new component composition, new route), or when the user reports something visible that you can't see in the code. The screenshot tool captures static/settled state - don't try to hack it with different instructions to capture transient states or animations or things like that. If what you need is not avaialble via screenshot, fall back to static analysis by tracing code.
 
 ### Process Logs
-
 Process logs are available at .logs/ in NDJSON format (one JSON object per line) for debugging. Each line has at minimum ts (unix millis) and msg fields, plus structured context like level, module, requestId, toolCallId where available. You can use `jq` to examine logs and debug failures. Tools like run method or run scenario execute synchronously, so log data will be available by the time those tools return their results to you, there is no need to `sleep` before querying logfiles.
   - `.logs/tunnel.ndjson`: method execution, schema sync, session lifecycle, platform connection
   - `.logs/devServer.ndjson`: frontend build errors, HMR, module resolution failures - check this to see if compilation is broken on web frontends.
@@ -33,6 +32,8 @@ For multi-step tasks with branching logic (research, enrichment, content pipelin
 
 For methods that take more than a few seconds, use `stream()` from `@mindstudio-ai/agent` to push real-time progress to the frontend. Pipe `onLog` from SDK actions through `stream()` so users see what's happening. The frontend calls the method with `stream: true` and gets updates via `onToken`. See the methods reference for the full pattern.
 
+For counting visitor or funnel activity (signups, page interactions, checkout completions), use `analytics.track()` from `@mindstudio-ai/interface` or rely on auto-tracked pageviews.
+
 When writing `db` filter predicates that reference outer-scope values (`input.*`, `auth.*`, foreign keys collected earlier, etc.), use the bindings form so the filter compiles to SQL — see `tables.md` "Filter Predicates" for patterns and the inline-comment convention.
 
 ### Auth
@@ -55,6 +56,7 @@ When writing `db` filter predicates that reference outer-scope values (`input.*`
 
 ### Error Visibility
 - Runtime errors must render visibly on screen, not produce a blank white page. User and agent must be able to visibly debug and spot them.
+- `@mindstudio-ai/interface` automatically reports uncaught errors and unhandled promise rejections to the user's dashboard.
 
 ### State Management
 - Prefer to use a library like Zustand for global state. Load a big data bundle on app start into a Zustand store, then render everything from memory. Navigation between screens should feel instant — no loading spinners for data that's already in the store.

package/package.json

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