Open-source AI coworkers that each get a computer of their own: a browser, files and tools, with every action decided before it happens and recorded after. Bring any AG-UI agent.
Hide the self-host banner from deployments that pay for Intelligence (#722)
David McKay488179268081
diff --git a/.env.example b/.env.exampleindex d814c862..478ddab2 100644--- a/.env.example+++ b/.env.example@@ -34,7 +34,8 @@ TENANT_PACKAGE_DIR=../examples/fintech# deployment that must not reach the public internet from a browser tab should set this to false.# OPENBOT_GENERATIVE_UI=false# The signed-in app shows a bar offering CopilotKit's help self-hosting OpenBot, until each person-# closes it. A fork running OpenBot for its own organization can turn it off for everybody.+# closes it. A deployment on a paid Intelligence plan never shows it. A fork running OpenBot for its+# own organization can turn it off for everybody.# OPENBOT_SELF_HOST_BANNER=false# What this deployment calls itself, when more than one shares an Intelligence project. A copy of a# deployment made for development uses the same project key, and threads are listed per Bot withdiff --git a/CHANGELOG.md b/CHANGELOG.mdindex 1062725c..11667df4 100644--- a/CHANGELOG.md+++ b/CHANGELOG.md@@ -8,7 +8,7 @@ Newest first. `Unreleased` is what is on `main` and not yet tagged.## Unreleased-**Before upgrading.** Four things change for an existing deployment:+**Before upgrading.** Six things change for an existing deployment:- Automatic Learning is on unless an administrator saved it off. It does nothing until a Learningcontainer is assigned; see below.- A Bot's computer refuses the network until the server pushes its policy. A computer run without@@ -19,12 +19,22 @@ Newest first. `Unreleased` is what is on `main` and not yet tagged.`0051_routine_enabled_at`.- An existing Windows clone checks text files out with LF only after`git rm -r --cached . && git reset --hard` on a clean tree.+- The signed-in app shows a bar offering CopilotKit's help self-hosting OpenBot, unless the+ deployment is on a paid Intelligence plan. Set `OPENBOT_SELF_HOST_BANNER=false` to remove it for+ everybody.+- An egress rule with a malformed IP range, such as `10.0.0.5/`, used to be read as `/0` and allow+ every IPv4 address. It is now refused, and a saved network policy that contains one is refused as+ a whole: the Bots under it fall back to an allowlist with nothing on it, so they reach nothing+ until the rule is corrected under Admin → Enterprise.### The app offers help self-hosting OpenBot, until you close itA slim bar at the top of the signed-in app links to CopilotKit's engineers for help self-hosting-OpenBot. Closing it is saved to your preferences, so it stays closed on every device. A fork running-OpenBot for its own organization hides it for everybody with `OPENBOT_SELF_HOST_BANNER=false`.+OpenBot. Closing it is saved to your preferences, so it stays closed on every device. A deployment+on a paid Intelligence plan (`pro`, `team`, `team_self_hosted` or `enterprise`, or a licence bought+through AWS Marketplace) never shows it; any other plan, or an entitlement that cannot be read,+shows it. A fork running OpenBot for its own organization hides it for everybody with+`OPENBOT_SELF_HOST_BANNER=false`.### A request to the approvals API that is not JSON answers 400diff --git a/app/src/lib/deployment/queries.ts b/app/src/lib/deployment/queries.tsindex 48bda770..7e968768 100644--- a/app/src/lib/deployment/queries.ts+++ b/app/src/lib/deployment/queries.ts@@ -20,7 +20,8 @@ export type DeploymentCapabilities = {generativeUi: boolean;/*** Whether to show the banner offering help self-hosting OpenBot. A fork that runs OpenBot for its- * own organization turns it off with OPENBOT_SELF_HOST_BANNER=false.+ * own organization turns it off with OPENBOT_SELF_HOST_BANNER=false, and the server answers false+ * for a deployment on a paid Intelligence plan.*/selfHostBanner: boolean;transcription?: boolean;diff --git a/docs/configuration.md b/docs/configuration.mdindex 3a989058..2d49de5d 100644--- a/docs/configuration.md+++ b/docs/configuration.md@@ -63,7 +63,7 @@ at `agent-langgraph` on a laptop.| `AUDIT_RETENTION_DAYS` | unset | Whole number of days to keep audit rows; older ones are removed. Unset keeps the trail forever. || `WORKER_SHARED_SECRET` | unset; `start.sh` uses a fixed local default | The secret the routines worker presents to fire a due routine. Without it the server refuses every handoff, whether or not a worker exists to send one. || `OPENBOT_GENERATIVE_UI` | unset (capability on) | Set `false` or `0` to stop Bots from answering with generated interfaces. |-| `OPENBOT_SELF_HOST_BANNER` | unset (banner on) | Set `false` or `0` to hide the bar offering help self-hosting OpenBot, for everybody. Each person can also close it for themselves. |+| `OPENBOT_SELF_HOST_BANNER` | unset (banner on) | Set `false` or `0` to hide the bar offering help self-hosting OpenBot, for everybody. It never shows on a paid Intelligence plan, and each person can also close it for themselves. || `OPENBOT_ACCESSIBILITY_DISABLED` | unset | `true` or `1` stops naming OpenBot on the analytics the runtime already sends. || `COMPOSIO_API_KEY` | unset | One key for the whole deployment, for the broker that holds people's accounts for a few hundred apps. Unset, there is nothing to connect, nothing to grant and no Composio tool for a Bot to call; what remains is one row that goes nowhere, under **More apps** on the admin Plugins page, naming this variable. See [Composio](plugins/composio.md). |@@ -78,7 +78,14 @@ setting through `/api/capabilities` to the browser.CopilotKit's help self-hosting OpenBot, linking to `https://copilotkit.ai/talk-to-an-engineer` with`ref=openbot_app`. Closing it is saved to that person's preferences, so it stays closed on everydevice they sign in from. Set `false` or `0` to hide it for everybody, which suits a fork running-OpenBot for its own organization. Any other value, or none, leaves it on. In Helm, set it through+OpenBot for its own organization. Any other value, or none, leaves it on.++Left on, it still never shows on a deployment that pays for Intelligence. The server reads the+deployment's Intelligence entitlement and hides the bar when it is active on a paid plan (`pro`,+`team`, `team_self_hosted` or `enterprise`) or comes from an AWS Marketplace licence. A free or+developer plan, an inactive entitlement, and one that cannot be read all show it. The answer is+kept for ten minutes, so a plan bought today hides the bar within ten minutes, and a page waits at+most a second for the first answer after the server starts. In Helm, set the variable through`config.extraEnv`.The component catalogue has separate per-Bot grants. Its sortable data table (`showTable`),diff --git a/server/src/app.ts b/server/src/app.tsindex ce45c43b..8e39653b 100644--- a/server/src/app.ts+++ b/server/src/app.ts@@ -81,6 +81,7 @@ import { createDictationRoutes } from "./dictation/routes";import type { HostAccessBroker } from "./host-access/broker";import { createHostAccessRoutes } from "./host-access/routes";import { createIntelligenceClient } from "./intelligence-client";+import type { SelfHostBanner } from "./self-host-banner";import {createLearningRoutes,type LearningAdminDependencies,@@ -413,6 +414,12 @@ export function createApp(/** Pause, reset, Activity and attention for a person's own Bots. See agents/lifecycle.ts. */lifecycle?: BotLifecycleServices;},+ /**+ * Whether to offer help self-hosting, which also hides it from a deployment that pays for+ * Intelligence. Absent falls back to the operator's switch alone, so a test or a build without the+ * resolver still answers from `config.selfHostBanner` rather than asking the network.+ */+ selfHostBanner?: SelfHostBanner,) {const app = new Hono<{ Variables: AppVariables }>();mountDesktopConnectionFailure(app, desktopHostToken);@@ -436,8 +443,11 @@ export function createApp(* both halves, so off means off.*/generativeUi: config.generativeUi,- // Whether to offer help self-hosting OpenBot. A fork running it for its own people turns it off.- selfHostBanner: config.selfHostBanner,+ // Whether to offer help self-hosting OpenBot. A fork running it for its own people turns it off,+ // and a deployment that pays for Intelligence never sees it. See self-host-banner.ts.+ selfHostBanner: selfHostBanner+ ? await selfHostBanner.shown()+ : config.selfHostBanner,transcription: Boolean(config.transcription),voice: Boolean(config.voice),/*diff --git a/server/src/config.ts b/server/src/config.tsindex 604c562f..34e28a70 100644--- a/server/src/config.ts+++ b/server/src/config.ts@@ -306,7 +306,8 @@ export type DeploymentConfig = {** On by default, because a fresh clone is somebody evaluating the template. A fork that runs* OpenBot for its own organization turns it off with OPENBOT_SELF_HOST_BANNER=false or- * OPENBOT_SELF_HOST_BANNER=0, since its people have nothing to self-host.+ * OPENBOT_SELF_HOST_BANNER=0, since its people have nothing to self-host. This is the operator's+ * switch only; a deployment on a paid Intelligence plan hides the bar too (self-host-banner.ts).*/selfHostBanner: boolean;/**diff --git a/server/src/index.ts b/server/src/index.tsindex 42db137d..972f672f 100644--- a/server/src/index.ts+++ b/server/src/index.ts@@ -172,7 +172,11 @@ import {HostAccessRefusedError,} from "./host-access/broker";import { hostAccessTools } from "./host-access/tools";-import { observeIntelligenceAuthentication } from "./intelligence-client";+import {+ createIntelligenceClient,+ observeIntelligenceAuthentication,+} from "./intelligence-client";+import { createSelfHostBanner } from "./self-host-banner";import { clearLearningRevisionFallback } from "./learning/runtime";import { createLearningSettingsStore } from "./learning/settings";import { createMemoryIngestion } from "./memory/ingestion";@@ -2859,6 +2863,12 @@ guardHostAccess();auditRoutineStore(routineStore, bootAuditStore);+// Asked only whether this deployment pays for Intelligence, for the self-host banner. Its own client+// rather than the runtime's, the same as the thread reader: the constructor opens nothing.+const selfHostBannerIntelligence = createIntelligenceClient(+ config.runtime.intelligence,+);+const app = createApp(config,auth,@@ -3038,6 +3048,10 @@ const app = createApp(auditStore: bootAuditStore,},},+ createSelfHostBanner({+ enabled: config.selfHostBanner,+ entitlements: () => selfHostBannerIntelligence.getRuntimeEntitlements(),+ }),);/**diff --git a/server/src/self-host-banner.ts b/server/src/self-host-banner.tsnew file mode 100644index 00000000..a88f81d7--- /dev/null+++ b/server/src/self-host-banner.ts@@ -0,0 +1,137 @@+import type { CopilotKitIntelligence } from "@copilotkit/runtime/v2";++/** What Intelligence says this deployment is entitled to. Typed from the client OpenBot already uses. */+export type RuntimeEntitlementResponse = Awaited<+ ReturnType<CopilotKitIntelligence["getRuntimeEntitlements"]>+>;++/**+ * The Intelligence plans that pay for it.+ *+ * `free` and `developer` are the no-cost tiers (the license verifier's `LicenseTier`), so they are+ * not here. A self-hosted licence reports its `plan_code`, or its tier when it has none, as the+ * plan code, so the same names cover managed and self-hosted deployments.+ */+const PAID_PLAN_CODES: ReadonlySet<string> = new Set([+ "pro",+ "team",+ "team_self_hosted",+ "enterprise",+]);++/**+ * Whether this deployment pays for Intelligence, read from its runtime entitlement.+ *+ * Only a ready, active entitlement on a paid plan counts, or one bought through AWS Marketplace,+ * which carries no plan code of ours. Everything else, including a free plan, an inactive one, a+ * missing plan code and every non-ready status, is not paying, so the banner shows. Being wrong in+ * that direction costs a dismissable bar; being wrong the other way hides it from the people it is+ * for.+ */+export function paysForIntelligence(+ response: RuntimeEntitlementResponse,+): boolean {+ if (response.status !== "ready" || !response.entitlement.active) return false;+ if (response.entitlement.source === "awsMarketplaceDeploymentLicense")+ return true;+ const plan = response.entitlement.planCode;+ return plan !== undefined && PAID_PLAN_CODES.has(plan);+}++export type SelfHostBanner = {+ /** Whether to offer help self-hosting. Never throws and never waits longer than `waitMs`. */+ shown: () => Promise<boolean>;+};++/**+ * How long a known answer is reused. A plan changes rarely and the bar is promotional, so ten+ * minutes keeps this to six entitlement reads an hour per replica while a plan bought today still+ * hides it within ten minutes.+ */+const ANSWER_TTL_MS = 10 * 60_000;+/** How long a failed read is held before trying again: soon enough to recover, not a hot loop. */+const FAILURE_TTL_MS = 60_000;+/**+ * The longest the first page load waits for an answer nobody has yet. The SDK's own request gives+ * up at 1.5 seconds; a page should not wait that long for a promotional bar, so after this the bar+ * shows and the answer, when it lands, applies to the next load.+ */+const COLD_WAIT_MS = 1_000;++/**+ * Decide, per deployment, whether the self-host banner shows.+ *+ * Off when the operator switched it off, which never asks Intelligence anything. Otherwise on unless+ * the deployment pays for Intelligence. The answer is cached in this process and refreshed in the+ * background when it goes stale, so a page load reads memory, not the network, after the first.+ */+export function createSelfHostBanner(options: {+ enabled: boolean;+ entitlements: () => Promise<RuntimeEntitlementResponse>;+ now?: () => number;+ ttlMs?: number;+ failureTtlMs?: number;+ waitMs?: number;+ log?: (message: string) => void;+}): SelfHostBanner {+ const now = options.now ?? Date.now;+ const ttlMs = options.ttlMs ?? ANSWER_TTL_MS;+ const failureTtlMs = options.failureTtlMs ?? FAILURE_TTL_MS;+ const waitMs = options.waitMs ?? COLD_WAIT_MS;+ const log = options.log ?? ((message: string) => console.warn(message));++ let answer: { shown: boolean; expiresAt: number } | undefined;+ let inFlight: Promise<boolean> | undefined;+ // Logged once per run of failures, not once per request: a page load every second against an+ // unreachable Intelligence would otherwise fill the log with the same line.+ let failureLogged = false;++ function refresh(): Promise<boolean> {+ if (inFlight) return inFlight;+ const request = options+ .entitlements()+ .then((response) => {+ const shown = !paysForIntelligence(response);+ answer = { shown, expiresAt: now() + ttlMs };+ failureLogged = false;+ return shown;+ })+ .catch((error: unknown) => {+ if (!failureLogged) {+ failureLogged = true;+ log(+ JSON.stringify({+ type: "self-host-banner-entitlement-unavailable",+ reason: error instanceof Error ? error.message : String(error),+ }),+ );+ }+ answer = { shown: true, expiresAt: now() + failureTtlMs };+ return true;+ })+ .finally(() => {+ if (inFlight === request) inFlight = undefined;+ });+ inFlight = request;+ return request;+ }++ return {+ async shown() {+ if (!options.enabled) return false;+ if (answer) {+ if (now() >= answer.expiresAt) void refresh();+ return answer.shown;+ }+ let timer: ReturnType<typeof setTimeout> | undefined;+ const timedOut = new Promise<boolean>((resolve) => {+ timer = setTimeout(() => resolve(true), waitMs);+ });+ try {+ return await Promise.race([refresh(), timedOut]);+ } finally {+ clearTimeout(timer);+ }+ },+ };+}diff --git a/server/tests/self-host-banner.test.ts b/server/tests/self-host-banner.test.tsnew file mode 100644index 00000000..db0b22f7--- /dev/null+++ b/server/tests/self-host-banner.test.ts@@ -0,0 +1,243 @@+import { describe, expect, test } from "bun:test";+import { createApp } from "../src/app";+import { loadConfig } from "../src/config";+import {+ createSelfHostBanner,+ paysForIntelligence,+ type RuntimeEntitlementResponse,+} from "../src/self-host-banner";+import { testEnvironment } from "./support/environment";++type Source =+ | "managedOrgSubscription"+ | "selfHostedDeploymentLicense"+ | "awsMarketplaceDeploymentLicense";++function ready(+ planCode: string | undefined,+ options: { active?: boolean; source?: Source } = {},+): RuntimeEntitlementResponse {+ return {+ status: "ready",+ entitlement: {+ active: options.active ?? true,+ source: options.source ?? "managedOrgSubscription",+ features: {},+ limits: {},+ ...(planCode === undefined ? {} : { planCode }),+ },+ };+}++function notReady(+ status: "degraded" | "misconfigured" | "unavailable",+): RuntimeEntitlementResponse {+ return {+ status,+ error: { code: "X", message: "not ready", retryable: true },+ };+}++describe("whether a deployment pays for Intelligence", () => {+ test.each(["pro", "team", "team_self_hosted", "enterprise"])(+ "%s is a paid plan",+ (plan) => {+ expect(paysForIntelligence(ready(plan))).toBe(true);+ expect(+ paysForIntelligence(+ ready(plan, { source: "selfHostedDeploymentLicense" }),+ ),+ ).toBe(true);+ },+ );++ test.each(["free", "developer", "something_new"])(+ "%s is not a paid plan",+ (plan) => {+ expect(paysForIntelligence(ready(plan))).toBe(false);+ },+ );++ test("an entitlement with no plan code is not paying", () => {+ expect(paysForIntelligence(ready(undefined))).toBe(false);+ });++ test("an AWS Marketplace licence pays, with or without a plan code", () => {+ expect(+ paysForIntelligence(+ ready(undefined, { source: "awsMarketplaceDeploymentLicense" }),+ ),+ ).toBe(true);+ });++ test("an inactive paid entitlement is not paying", () => {+ expect(paysForIntelligence(ready("enterprise", { active: false }))).toBe(+ false,+ );+ expect(+ paysForIntelligence(+ ready(undefined, {+ active: false,+ source: "awsMarketplaceDeploymentLicense",+ }),+ ),+ ).toBe(false);+ });++ test.each(["degraded", "misconfigured", "unavailable"] as const)(+ "a %s entitlement is not paying",+ (status) => {+ expect(paysForIntelligence(notReady(status))).toBe(false);+ },+ );+});++describe("the self-host banner", () => {+ test("is off when the operator switched it off, without asking Intelligence", async () => {+ let asked = 0;+ const banner = createSelfHostBanner({+ enabled: false,+ entitlements: async () => {+ asked += 1;+ return ready("free");+ },+ });+ expect(await banner.shown()).toBe(false);+ expect(asked).toBe(0);+ });++ test("shows on a free plan and hides on a paid one", async () => {+ const free = createSelfHostBanner({+ enabled: true,+ entitlements: async () => ready("free"),+ });+ const paid = createSelfHostBanner({+ enabled: true,+ entitlements: async () => ready("team"),+ });+ expect(await free.shown()).toBe(true);+ expect(await paid.shown()).toBe(false);+ });++ test("shows when the entitlement cannot be read, and says so once", async () => {+ const logged: string[] = [];+ const banner = createSelfHostBanner({+ enabled: true,+ failureTtlMs: 0,+ entitlements: async () => {+ throw new Error("Intelligence is unreachable");+ },+ log: (line) => logged.push(line),+ });+ expect(await banner.shown()).toBe(true);+ expect(await banner.shown()).toBe(true);+ await Bun.sleep(0);+ expect(await banner.shown()).toBe(true);+ expect(logged).toHaveLength(1);+ expect(logged[0]).toContain("Intelligence is unreachable");+ });++ test("does not hold a page load longer than it allows", async () => {+ const banner = createSelfHostBanner({+ enabled: true,+ waitMs: 20,+ entitlements: () => new Promise(() => {}),+ });+ const started = performance.now();+ expect(await banner.shown()).toBe(true);+ expect(performance.now() - started).toBeLessThan(500);+ });++ test("reuses a known answer instead of asking again", async () => {+ let asked = 0;+ const banner = createSelfHostBanner({+ enabled: true,+ entitlements: async () => {+ asked += 1;+ return ready("enterprise");+ },+ });+ expect(await banner.shown()).toBe(false);+ expect(await banner.shown()).toBe(false);+ expect(await banner.shown()).toBe(false);+ expect(asked).toBe(1);+ });++ test("answers from memory when stale and refreshes behind it", async () => {+ let clock = 0;+ let plan = "pro";+ let asked = 0;+ const banner = createSelfHostBanner({+ enabled: true,+ ttlMs: 100,+ now: () => clock,+ entitlements: async () => {+ asked += 1;+ return ready(plan);+ },+ });+ expect(await banner.shown()).toBe(false);+ plan = "free";+ clock = 200;+ // The stale answer is returned at once; the plan change applies once the refresh lands.+ expect(await banner.shown()).toBe(false);+ await Bun.sleep(0);+ expect(asked).toBe(2);+ expect(await banner.shown()).toBe(true);+ });++ test("asks once for many page loads that arrive together", async () => {+ let asked = 0;+ const banner = createSelfHostBanner({+ enabled: true,+ entitlements: async () => {+ asked += 1;+ await Bun.sleep(5);+ return ready("free");+ },+ });+ const answers = await Promise.all([+ banner.shown(),+ banner.shown(),+ banner.shown(),+ ]);+ expect(answers).toEqual([true, true, true]);+ expect(asked).toBe(1);+ });+});++describe("the capabilities endpoint", () => {+ const config = loadConfig(testEnvironment());++ // createApp takes its services positionally, and the banner is the last of them.+ function appWith(banner: ReturnType<typeof createSelfHostBanner>) {+ const args: unknown[] = new Array(createApp.length).fill(undefined);+ args[0] = config;+ args[args.length - 1] = banner;+ return (createApp as (...input: unknown[]) => ReturnType<typeof createApp>)(+ ...args,+ );+ }++ test("hides the banner from a deployment that pays for Intelligence", async () => {+ const app = appWith(+ createSelfHostBanner({+ enabled: true,+ entitlements: async () => ready("enterprise"),+ }),+ );+ const response = await app.request("/api/capabilities");+ expect((await response.json()).selfHostBanner).toBe(false);+ });++ test("shows it on a free plan", async () => {+ const app = appWith(+ createSelfHostBanner({+ enabled: true,+ entitlements: async () => ready("free"),+ }),+ );+ const response = await app.request("/api/capabilities");+ expect((await response.json()).selfHostBanner).toBe(true);+ });+});