@shubh90/app-runtime 0.4.0 → 0.4.1

package/README.md

@@ -29,11 +29,20 @@ and autosave never fights a kit-dirtied tree. Apps pin a version; a breaking
 Plaza contract change is a semver major with a deprecation window, not a flag
 day.
 
-## Publishing (GitHub Packages)
+## Publishing (npmjs, public)
 
-Built and published from the monorepo on a `app-runtime-v*` tag by
-`.github/workflows/publish-app-runtime.yml`. The registry is
-`npm.pkg.github.com`, scope `@mii`.
+Every released version (0.1.0 →) lives on the PUBLIC npm registry — that is
+where app installs resolve, with no auth to provision in any build
+environment, which is the point. Publish from a machine logged in as
+`shubh90`:
+
+```bash
+# from packages/app-runtime, after npm run check && npm run build:
+npm publish --registry=https://registry.npmjs.org
+```
+
+The `app-runtime-v*` tag workflow publishes a mirror copy to GitHub Packages;
+nothing installs from there today, so treat npmjs as the source of truth.
 
 ```bash
 # maintainers, from packages/app-runtime:

package/dist/platform/index.d.ts

@@ -51,7 +51,8 @@ export type MiiAnalyticsPolicy = {
     /** posthog-js init options: `posthog.init("in-house", options)`. */
     readonly options: {
         readonly api_host: string;
-        readonly defaults: string;
+        /** posthog-js "defaults era" — a date literal its ConfigDefaults union accepts. */
+        readonly defaults: "2026-06-25";
         readonly person_profiles: "identified_only";
         readonly advanced_disable_flags: true;
         readonly disable_external_dependency_loading: true;

package/dist/server/build-marker.d.ts

@@ -0,0 +1,10 @@
+export type BuildMarkerOptions = {
+    /** Defaults to VERCEL_DEPLOYMENT_ID / VERCEL_GIT_COMMIT_SHA, read per request. */
+    readonly deploymentId?: () => string | undefined;
+    readonly commitSha?: () => string | undefined;
+};
+/** GET + OPTIONS for /api/mii-build; mount both from one factory. */
+export declare function createBuildMarkerHandler(options?: BuildMarkerOptions): {
+    GET(request: Request): Response;
+    OPTIONS(request: Request): Response;
+};

package/dist/server/build-marker.js

@@ -0,0 +1,51 @@
+// Which build of this app is currently serving.
+//
+// Plaza's App pane is an iframe of the deployment. When an agent ships, the
+// URL does not move, so nothing tells the pane the page underneath it is now
+// stale — the pane polls this and reloads the frame when the answer changes.
+// Plaza's server asks the same question for agents (deployedCommitOf), which
+// is why this stays a route on the app: "the domain answers with this commit"
+// is a stronger claim than any deploy provider's READY, and it needs no
+// provider token to work.
+//
+// Deliberately touches nothing: no database, no imports beyond the origin
+// list. It is polled every few seconds by every open pane, so it has to be
+// the cheapest route in the app — the health check next door opens a Postgres
+// connection and would wake the database on a timer forever.
+import { PLAZA_FRAME_ORIGINS } from "../platform/index.js";
+function corsHeaders(origin) {
+    // Echo the caller's origin only when it is a Plaza we know. `*` would let
+    // any page on the internet read this; harmless today, but this is the
+    // pattern the next endpoint copies, and the next one may not be harmless.
+    return origin !== null && PLAZA_FRAME_ORIGINS.includes(origin)
+        ? {
+            "Access-Control-Allow-Origin": origin,
+            Vary: "Origin",
+            "Cache-Control": "no-store"
+        }
+        : { "Cache-Control": "no-store" };
+}
+/** GET + OPTIONS for /api/mii-build; mount both from one factory. */
+export function createBuildMarkerHandler(options = {}) {
+    const deploymentId = options.deploymentId ?? (() => process.env.VERCEL_DEPLOYMENT_ID);
+    const commitSha = options.commitSha ?? (() => process.env.VERCEL_GIT_COMMIT_SHA);
+    return {
+        GET(request) {
+            // The deployment id changes on every deploy, including a redeploy of the
+            // same commit — which is exactly the question being asked. The commit
+            // rides along because it is the half a human can act on.
+            const deployment = deploymentId() ?? null;
+            const commit = commitSha() ?? null;
+            return Response.json({ build: deployment ?? commit, commit }, { headers: corsHeaders(request.headers.get("origin")) });
+        },
+        OPTIONS(request) {
+            return new Response(null, {
+                status: 204,
+                headers: {
+                    ...corsHeaders(request.headers.get("origin")),
+                    "Access-Control-Allow-Methods": "GET, OPTIONS"
+                }
+            });
+        }
+    };
+}

package/dist/server/index.d.ts

@@ -1,6 +1,8 @@
 import { type DbRetryOptions } from "./db-retry.js";
 export { withDbRetry, isTransientConnectionError, DB_RETRY_ATTEMPTS } from "./db-retry.js";
 export type { DbRetryOptions } from "./db-retry.js";
+export { createBuildMarkerHandler, type BuildMarkerOptions } from "./build-marker.js";
+export { createSentryTunnelHandler, type SentryTunnelOptions } from "./sentry-tunnel.js";
 export type HealthHandlerOptions = {
     /** Defaults to process.env.DATABASE_URL, read per request. */
     readonly databaseUrl?: () => string | undefined;

package/dist/server/index.js

@@ -6,6 +6,8 @@
 import postgres from "postgres";
 import { withDbRetry } from "./db-retry.js";
 export { withDbRetry, isTransientConnectionError, DB_RETRY_ATTEMPTS } from "./db-retry.js";
+export { createBuildMarkerHandler } from "./build-marker.js";
+export { createSentryTunnelHandler } from "./sentry-tunnel.js";
 /**
  * GET /api/health — the readiness gate. The sandbox refuses to report an
  * instance as up, and Plaza refuses to wake one, until this answers ok. It

package/dist/server/sentry-tunnel.d.ts

@@ -0,0 +1,6 @@
+export type SentryTunnelOptions = {
+    /** Test hook; defaults to global fetch. */
+    readonly fetch?: typeof fetch;
+};
+/** POST for /monitoring: forward the envelope, answer what Sentry answered. */
+export declare function createSentryTunnelHandler(options?: SentryTunnelOptions): (request: Request) => Promise<Response>;

package/dist/server/sentry-tunnel.js

@@ -0,0 +1,43 @@
+// The Sentry tunnel: browsers post error envelopes to this app's own
+// /monitoring route, which forwards them to Sentry — because ad-blockers
+// block *.sentry.io from the browser, and a platform whose error reporting
+// dies to a browser extension is blind exactly where it matters.
+//
+// The envelope's own header names the DSN, so the route needs no
+// configuration; it forwards only to hosts that are plainly Sentry's, so an
+// app cannot be turned into an open relay by a crafted envelope.
+const ALLOWED_HOST = /(^|\.)(sentry\.io|ingest\.sentry\.io|ingest\.[a-z0-9-]+\.sentry\.io)$/;
+/** POST for /monitoring: forward the envelope, answer what Sentry answered. */
+export function createSentryTunnelHandler(options = {}) {
+    const doFetch = options.fetch ?? fetch;
+    return async function tunnel(request) {
+        const envelope = await request.text();
+        const newline = envelope.indexOf("\n");
+        const headerLine = newline === -1 ? envelope : envelope.slice(0, newline);
+        let dsn;
+        try {
+            const header = JSON.parse(headerLine);
+            if (typeof header.dsn !== "string") {
+                return Response.json({ error: "Envelope names no DSN." }, { status: 400 });
+            }
+            dsn = new URL(header.dsn);
+        }
+        catch {
+            return Response.json({ error: "Not a Sentry envelope." }, { status: 400 });
+        }
+        if (!ALLOWED_HOST.test(dsn.hostname)) {
+            // A DSN pointing anywhere else would make this route an open relay.
+            return Response.json({ error: "DSN host is not Sentry." }, { status: 400 });
+        }
+        const projectId = dsn.pathname.replace(/^\/+/, "");
+        if (!/^\d+$/.test(projectId)) {
+            return Response.json({ error: "DSN names no project." }, { status: 400 });
+        }
+        const upstream = await doFetch(`https://${dsn.hostname}/api/${projectId}/envelope/`, {
+            method: "POST",
+            headers: { "Content-Type": "application/x-sentry-envelope" },
+            body: envelope
+        });
+        return new Response(null, { status: upstream.status });
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shubh90/app-runtime",
-  "version": "0.4.0",
+  "version": "0.4.1",
   "description": "The platform contract every mii org app depends on — sign-in, and the Next.js config an app must not diverge from. A versioned package, not files copied into each repo.",
   "license": "UNLICENSED",
   "type": "module",