Gate generated UI behind feature flag

Author: RhysSullivan

apps/cli/src/main.ts

@@ -59,7 +59,12 @@ import * as Option from "effect/Option";
 import * as Cause from "effect/Cause";
 
 import { ExecutorApi } from "@executor-js/api";
-import { startServer, runMcpStdioServer, getExecutor } from "@executor-js/local";
+import {
+  startServer,
+  runMcpStdioServer,
+  getExecutor,
+  makeLocalEnvFeatureFlags,
+} from "@executor-js/local";
 import { makeQuickJsExecutor } from "@executor-js/runtime-quickjs";
 import { fetchIntegrations } from "./integrations";
 import {
@@ -778,6 +783,7 @@ const runStdioMcpSession = (input: { readonly elicitationMode: "browser" | "mode
         runMcpStdioServer({
           executor: web.executor,
           codeExecutor: makeQuickJsExecutor(),
+          featureFlags: makeLocalEnvFeatureFlags(),
           renderUiFallbackUrl: (code) => {
             const url = new URL("/plugins/dynamic-ui/render", web.baseUrl);
             url.hash = `code=${encodeURIComponent(code)}`;

apps/cloud/src/api/core-shared-services.ts

@@ -15,11 +15,16 @@ import { Layer } from "effect";
 
 import { WorkOSAuth } from "../auth/workos";
 import { AutumnService } from "../services/autumn";
+import { PostHogFeatureFlags } from "../services/feature-flags";
 
 /**
  * Services that are independent of how the DB or tracer is provisioned —
  * both the stateless HTTP path (per-request DB via Hyperdrive) and the MCP
  * session DO (long-lived DB + isolate-local tracer SDK) merge this with
  * their own `DbLive` + `UserStoreLive` + telemetry layer.
  */
-export const CoreSharedServices = Layer.mergeAll(WorkOSAuth.Default, AutumnService.Default);
+export const CoreSharedServices = Layer.mergeAll(
+  WorkOSAuth.Default,
+  AutumnService.Default,
+  PostHogFeatureFlags,
+);

apps/cloud/src/env-augment.d.ts

@@ -14,6 +14,7 @@ declare global {
       VITE_PUBLIC_SENTRY_DSN?: string;
       VITE_PUBLIC_POSTHOG_KEY?: string;
       VITE_PUBLIC_POSTHOG_HOST?: string;
+      POSTHOG_HOST?: string;
 
       // Datastore. Prod uses HYPERDRIVE when the binding exists; direct
       // DATABASE_URL is only selected when explicitly requested for local/test.

apps/cloud/src/mcp-session.ts

@@ -371,6 +371,12 @@ export class McpSessionDO extends DurableObject {
         plugins,
         parentSpan: () => self.currentRequestSpan ?? undefined,
         debug: env.EXECUTOR_MCP_DEBUG === "true",
+        featureFlagContext: {
+          distinctId: sessionMeta.userId,
+          accountId: sessionMeta.userId,
+          organizationId: sessionMeta.organizationId,
+          groups: { organization: sessionMeta.organizationId },
+        },
         renderUiFallbackUrl: (code) => {
           const origin = env.VITE_PUBLIC_SITE_URL ?? "https://executor.sh";
           const url = new URL("/plugins/dynamic-ui/render", origin);

apps/cloud/src/services/feature-flags.ts

@@ -0,0 +1,66 @@
+import { env } from "cloudflare:workers";
+import { Data, Effect, Layer, Option, Schema } from "effect";
+import {
+  FeatureFlags,
+  type FeatureFlagContext,
+  type FeatureFlagsShape,
+} from "@executor-js/host-mcp";
+
+class PostHogFeatureFlagError extends Data.TaggedError("PostHogFeatureFlagError")<{
+  readonly cause: unknown;
+}> {}
+
+const FeatureFlagsResponse = Schema.Struct({
+  featureFlags: Schema.optional(Schema.Record(Schema.String, Schema.Unknown)),
+});
+const decodeFeatureFlagsResponse = Schema.decodeUnknownOption(FeatureFlagsResponse);
+
+const postHogHost = (): string => (env.POSTHOG_HOST ?? "https://us.i.posthog.com").replace(/\/$/, "");
+
+const flagValueEnabled = (value: unknown): boolean =>
+  value !== false && value !== null && value !== undefined;
+
+const distinctIdFor = (context: FeatureFlagContext): string =>
+  context.distinctId ?? context.accountId ?? context.organizationId ?? "executor-cloud";
+
+const groupsFor = (context: FeatureFlagContext): Record<string, string> | undefined => {
+  const groups = {
+    ...(context.groups ?? {}),
+    ...(context.organizationId ? { organization: context.organizationId } : {}),
+  };
+  return Object.keys(groups).length > 0 ? groups : undefined;
+};
+
+export const makePostHogFeatureFlags = (): FeatureFlagsShape => ({
+  isEnabled: (flag, context) =>
+    Effect.gen(function* () {
+      const apiKey = env.VITE_PUBLIC_POSTHOG_KEY;
+      if (!apiKey) return false;
+
+      const response = yield* Effect.tryPromise({
+        try: () =>
+          fetch(`${postHogHost()}/decide/?v=3`, {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify({
+              api_key: apiKey,
+              distinct_id: distinctIdFor(context),
+              groups: groupsFor(context),
+            }),
+          }),
+        catch: (cause) => new PostHogFeatureFlagError({ cause }),
+      });
+
+      if (!response.ok) return false;
+
+      const raw = yield* Effect.tryPromise({
+        try: () => response.json(),
+        catch: (cause) => new PostHogFeatureFlagError({ cause }),
+      });
+      const decoded = decodeFeatureFlagsResponse(raw);
+      if (Option.isNone(decoded)) return false;
+      return flagValueEnabled(decoded.value.featureFlags?.[flag]);
+    }).pipe(Effect.withSpan("feature_flags.posthog.is_enabled", { attributes: { flag } })),
+});
+
+export const PostHogFeatureFlags = Layer.succeed(FeatureFlags, makePostHogFeatureFlags());

apps/local/src/index.ts

@@ -13,4 +13,5 @@ export {
   type LocalExecutor,
 } from "./server/executor";
 export { createMcpRequestHandler, runMcpStdioServer, type McpRequestHandler } from "./server/mcp";
+export { makeLocalEnvFeatureFlags, LocalEnvFeatureFlags } from "./server/feature-flags";
 export { startServer, type StartServerOptions, type ServerInstance } from "./serve";

apps/local/src/server/feature-flags.ts

@@ -0,0 +1,31 @@
+import { Effect, Layer } from "effect";
+import {
+  FEATURE_FLAG_GENERATED_UI_MCP_APPS,
+  FeatureFlags,
+  type FeatureFlagsShape,
+} from "@executor-js/host-mcp";
+
+const truthy = (value: string | undefined): boolean =>
+  value === "1" || value === "true" || value === "TRUE" || value === "yes" || value === "on";
+
+const envNameForFlag = (flag: string): string =>
+  `EXECUTOR_FEATURE_${flag.replaceAll(/[^A-Za-z0-9]+/g, "_").replace(/^_+|_+$/g, "").toUpperCase()}`;
+
+const readFlag = (flag: string, env: NodeJS.ProcessEnv): boolean => {
+  const generic = env[envNameForFlag(flag)];
+  if (generic !== undefined) return truthy(generic);
+
+  if (flag === FEATURE_FLAG_GENERATED_UI_MCP_APPS) {
+    return truthy(env.EXECUTOR_GENERATED_UI) || truthy(env.EXECUTOR_DYNAMIC_UI);
+  }
+
+  return false;
+};
+
+export const makeLocalEnvFeatureFlags = (
+  env: NodeJS.ProcessEnv = process.env,
+): FeatureFlagsShape => ({
+  isEnabled: (flag) => Effect.sync(() => readFlag(flag, env)),
+});
+
+export const LocalEnvFeatureFlags = Layer.succeed(FeatureFlags, makeLocalEnvFeatureFlags());

apps/local/src/server/main.ts

@@ -15,6 +15,7 @@ import { makeQuickJsExecutor } from "@executor-js/runtime-quickjs";
 import { getExecutorBundle } from "./executor";
 import { createMcpRequestHandler, type McpRequestHandler } from "./mcp";
 import { ErrorCaptureLive } from "./observability";
+import { makeLocalEnvFeatureFlags } from "./feature-flags";
 
 // ---------------------------------------------------------------------------
 // Local server API.
@@ -98,7 +99,7 @@ export const createServerHandlers = async (): Promise<ServerHandlers> => {
     dispose: api.dispose,
   };
 
-  const mcp = createMcpRequestHandler({ engine, plugins });
+  const mcp = createMcpRequestHandler({ engine, plugins, featureFlags: makeLocalEnvFeatureFlags() });
 
   return { api: apiHandler, mcp };
 };

packages/hosts/mcp/src/feature-flags.ts

@@ -0,0 +1,29 @@
+import { Context, Effect, Layer } from "effect";
+
+export const FEATURE_FLAG_GENERATED_UI_MCP_APPS = "generated-ui-mcp-apps";
+
+export type FeatureFlagContext = {
+  readonly distinctId?: string;
+  readonly accountId?: string;
+  readonly organizationId?: string;
+  readonly groups?: Record<string, string>;
+};
+
+export type FeatureFlagsShape = {
+  readonly isEnabled: (
+    flag: string,
+    context: FeatureFlagContext,
+  ) => Effect.Effect<boolean, unknown, never>;
+};
+
+export class FeatureFlags extends Context.Service<FeatureFlags, FeatureFlagsShape>()(
+  "@executor-js/host-mcp/FeatureFlags",
+) {
+  static readonly Disabled: Layer.Layer<FeatureFlags> = Layer.succeed(FeatureFlags, {
+    isEnabled: () => Effect.succeed(false),
+  });
+
+  static readonly Enabled: Layer.Layer<FeatureFlags> = Layer.succeed(FeatureFlags, {
+    isEnabled: () => Effect.succeed(true),
+  });
+}

packages/hosts/mcp/src/index.ts

@@ -1,4 +1,10 @@
 export { createExecutorMcpServer, type ExecutorMcpServerConfig } from "./server";
+export {
+  FEATURE_FLAG_GENERATED_UI_MCP_APPS,
+  FeatureFlags,
+  type FeatureFlagContext,
+  type FeatureFlagsShape,
+} from "./feature-flags";
 export {
   defineMcpContribution,
   type McpDebugLog,