@iloveagents/foundry-web-shell 0.2.1 → 0.3.0

package/CHANGELOG.md

@@ -1,5 +1,65 @@
 # @iloveagents/foundry-web-shell
 
+## 0.3.0
+
+### Minor Changes
+
+- df383c9: Add runtime configuration support so the web app can ship as a single prebuilt
+  container image that boots for any environment without a rebuild. New
+  `runtimeConfig(key)` helper resolves `window.__APP_CONFIG__[key]` (injected by
+  the container at startup) before `import.meta.env[key]` (build-time Vite env,
+  the local-dev fallback). The default MSAL auth adapter and agent fetch client
+  now read `VITE_MSAL_*` / `VITE_API_BASE_URL` through it. Local `pnpm dev` is
+  unchanged (no `/config.js` → falls back to `import.meta.env`).
+
+### Patch Changes
+
+- @iloveagents/foundry-agent@0.3.0
+- @iloveagents/foundry-web-primitives@0.3.0
+- @iloveagents/foundry-web-ui@0.3.0
+
+## 0.2.2
+
+### Patch Changes
+
+- 8184a8c: shell: URL is authoritative for the runtime threadId — fixes
+  resume-creates-new-conversation race
+
+  `ChatConversationAwareRuntime` previously computed
+  `effectiveThreadId = sticky ?? urlMatch ?? freshIdRef.current`.
+  When the user navigated from one chat to another via a Recents
+  click, the synchronous render that followed the URL change had:
+  - `urlMatch = B` (read from the now-updated `useLocation`)
+  - `sticky = A` (the active-chat-store hadn't been updated by
+    `useTrackActiveChatFromUrl`'s `useEffect` yet — effects run
+    AFTER the commit phase)
+
+  `sticky ?? urlMatch` picked `A` (the previous chat). The AG-UI
+  adapter was constructed with `threadId = A`. The first message the
+  user sent went to `/api/agent` with `thread_id = A`, the middleware
+  created a new row keyed by `A`... wait actually no, here's what
+  happens — the runtime mints a fresh runner UUID when given a
+  mismatched threadId; that fresh UUID became a new conversation row,
+  appearing as "Untitled chat" at the top of the sidebar while the
+  URL still said `/chat/B`. Two active-looking dots: one for `B`
+  (NavLink URL match), one for the new row (statusDot from the
+  updated active-chat-store after the lazy ensure ran).
+
+  Swap the priority: `urlMatch ?? sticky ?? freshIdRef.current`. The
+  URL is authoritative whenever it's set (i.e. on `/chat/<id>`
+  routes), eliminating the stale-sticky race entirely. `sticky` is
+  still consulted as the second-priority fallback for non-chat
+  routes (`/spaces`, `/tasks`) so the popout chat stays "live" while
+  the user browses workspaces — that's the original purpose of
+  `useStickyConversationId` and it's preserved.
+
+- Updated dependencies [395f0cd]
+- Updated dependencies [1ba01ef]
+- Updated dependencies [8184a8c]
+  - @iloveagents/foundry-web-ui@0.2.2
+  - @iloveagents/foundry-agent@0.2.2
+  - @iloveagents/foundry-web-primitives@0.2.2
+
 ## 0.2.1
 
 ### Patch Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@iloveagents/foundry-web-shell",
-  "version": "0.2.1",
+  "version": "0.3.0",
   "license": "SEE LICENSE IN LICENSE",
   "type": "module",
   "types": "./src/index.ts",
@@ -19,9 +19,9 @@
     "zustand": "^5.0.0"
   },
   "dependencies": {
-    "@iloveagents/foundry-agent": "0.2.1",
-    "@iloveagents/foundry-web-primitives": "0.2.1",
-    "@iloveagents/foundry-web-ui": "0.2.1"
+    "@iloveagents/foundry-agent": "0.3.0",
+    "@iloveagents/foundry-web-primitives": "0.3.0",
+    "@iloveagents/foundry-web-ui": "0.3.0"
   },
   "devDependencies": {
     "typescript": "~5.9.3",

package/src/auth-default.tsx

@@ -2,6 +2,7 @@ import type { FC, ReactNode } from "react";
 import { AuthProvider } from "@iloveagents/foundry-web-ui";
 import type { MsalAuthConfig } from "@iloveagents/foundry-agent/msal";
 import type { AuthAdapter } from "./types.ts";
+import { runtimeConfig } from "./runtime-config.ts";
 
 
 
@@ -23,15 +24,16 @@ function AuthConfigError({ missingKeys }: AuthConfigErrorProps) {
 }
 
 /**
- * Read MSAL configuration from Vite env. Returns the resolved config or the
- * list of missing keys. The shell renders <AuthConfigError /> when any key
- * is missing.
+ * Read MSAL configuration. Prefers runtime config (`window.__APP_CONFIG__`,
+ * injected by the container at startup) and falls back to build-time Vite env
+ * (`import.meta.env`) for local dev — see {@link runtimeConfig}. Returns the
+ * resolved config or the list of missing keys; the shell renders
+ * <AuthConfigError /> when any key is missing.
  */
-function readMsalConfigFromEnv(): MsalAuthConfig | { missing: string[] } {
-  const env = import.meta.env;
-  const clientId = env.VITE_MSAL_CLIENT_ID;
-  const authority = env.VITE_MSAL_AUTHORITY;
-  const apiScope = env.VITE_MSAL_API_SCOPE;
+function readMsalConfig(): MsalAuthConfig | { missing: string[] } {
+  const clientId = runtimeConfig("VITE_MSAL_CLIENT_ID");
+  const authority = runtimeConfig("VITE_MSAL_AUTHORITY");
+  const apiScope = runtimeConfig("VITE_MSAL_API_SCOPE");
   const missing = [
     !clientId ? "VITE_MSAL_CLIENT_ID" : null,
     !authority ? "VITE_MSAL_AUTHORITY" : null,
@@ -39,21 +41,22 @@ function readMsalConfigFromEnv(): MsalAuthConfig | { missing: string[] } {
   ].filter((v): v is string => v !== null);
   if (missing.length > 0) return { missing };
   return {
-    clientId: clientId!,
-    authority: authority!,
-    apiScope: apiScope!,
+    clientId,
+    authority,
+    apiScope,
     redirectUri: window.location.origin,
   };
 }
 
 /**
- * Default MSAL-backed auth adapter. Reads VITE_MSAL_* from import.meta.env.
+ * Default MSAL-backed auth adapter. Reads VITE_MSAL_* from runtime config
+ * (`window.__APP_CONFIG__`) with `import.meta.env` fallback for local dev.
  * Customers override via `bootstrapShell({ authProvider: { Provider: ... } })`
  * for tests or non-MSAL deployments.
  */
 export const defaultAuthAdapter: AuthAdapter = {
   Provider: ({ children }: { children: ReactNode }) => {
-    const result = readMsalConfigFromEnv();
+    const result = readMsalConfig();
     if ("missing" in result) {
       return <AuthConfigError missingKeys={result.missing} />;
     }

package/src/index.ts

@@ -3,6 +3,7 @@ export { ShellApp } from "./shell-app.tsx";
 export { ShellLayout } from "./shell-layout.tsx";
 export { defaultAuthAdapter, ShellAuth } from "./auth-default.tsx";
 export { defaultAgentFetch } from "./service-fetch-default.ts";
+export { runtimeConfig } from "./runtime-config.ts";
 export { defineChatModule } from "./types.ts";
 export type {
   ChatModule,

package/src/runtime-config.ts

@@ -0,0 +1,30 @@
+/**
+ * Runtime configuration reader.
+ *
+ * The web app ships as a SINGLE prebuilt container image that must boot
+ * correctly for any customer / environment without a rebuild. Per-env values
+ * (API base URL, MSAL client/authority/scopes) therefore arrive at RUNTIME —
+ * the container entrypoint writes a small `/config.js` from env vars that sets
+ * `window.__APP_CONFIG__`, loaded before the app bundle.
+ *
+ * `runtimeConfig(key)` resolves, in order:
+ *   1. `window.__APP_CONFIG__[key]`  — runtime config injected by the container
+ *   2. `import.meta.env[key]`        — build-time Vite env (local `pnpm dev`)
+ *   3. `""`                          — absent
+ *
+ * Keeping `import.meta.env` as the fallback means local dev is unchanged: there
+ * is no `/config.js` in dev, so `window.__APP_CONFIG__` is undefined and the
+ * existing `VITE_*` values from `.env` are used exactly as before.
+ *
+ * The window cast is inline (no `declare global`) so this can be duplicated in
+ * sibling packages without conflicting global augmentations.
+ */
+export function runtimeConfig(key: string): string {
+  const fromWindow =
+    typeof window !== "undefined"
+      ? (window as { __APP_CONFIG__?: Record<string, string | undefined> })
+          .__APP_CONFIG__?.[key]
+      : undefined;
+  const fromEnv = (import.meta.env as Record<string, string | undefined>)[key];
+  return fromWindow ?? fromEnv ?? "";
+}

package/src/service-fetch-default.ts

@@ -1,5 +1,6 @@
 import { createServiceFetch } from "@iloveagents/foundry-agent";
 import { authStore } from "@iloveagents/foundry-agent/msal";
+import { runtimeConfig } from "./runtime-config.ts";
 
 /**
  * Default agent fetch client wired to the MSAL token store and the host's
@@ -21,5 +22,5 @@ export const defaultAgentFetch: typeof fetch = createServiceFetch({
   acquireToken: (options) => authStore.getState().getAccessToken("api", options),
   recoverFromHardAuthFailure: (reason) =>
     authStore.getState().recoverFromHardAuthFailure(reason),
-  baseUrl: import.meta.env.VITE_API_BASE_URL,
+  baseUrl: runtimeConfig("VITE_API_BASE_URL"),
 });

package/src/shell-app.tsx

@@ -283,9 +283,39 @@ function RuntimeBody({
   prevStickyRef.current = sticky;
 
   // Effective id seen by AGUIRuntimeProvider — always defined.
-  //   sticky (current conversation) wins, else fall back to the
-  //   shell-minted UUID for fresh chats.
-  const effectiveThreadId: string = sticky ?? urlMatch ?? freshIdRef.current;
+  //
+  // Priority order matters and is intentional:
+  //   1. ``urlMatch`` — when the user is on ``/chat/<id>`` the URL is
+  //      ALWAYS the authoritative conversation. This MUST come before
+  //      ``sticky`` because of a stale-render race on cross-chat
+  //      navigation:
+  //        - User is on ``/chat/A``. ``active-chat-store`` holds ``A``.
+  //          So ``sticky = A``.
+  //        - User clicks a Recents row for ``B`` →
+  //          ``react-router`` updates pathname to ``/chat/B``.
+  //        - On the synchronous render that follows, ``urlMatch`` is
+  //          ``B`` (read from ``useLocation``) but
+  //          ``useTrackActiveChatFromUrl``'s ``useEffect`` hasn't run
+  //          yet — so ``sticky`` is still ``A``.
+  //        - With ``sticky ?? urlMatch`` we'd compute
+  //          ``effectiveThreadId = A``, bind the AG-UI adapter to ``A``,
+  //          and the first message the user sends would create a NEW
+  //          row at ``A``'s old thread id while the URL says ``B``.
+  //          Symptoms: TWO active dots in the sidebar (URL highlights
+  //          row ``B``, the new row's id activates the dot on a
+  //          freshly-appeared "Untitled chat"); resume appears to
+  //          mint a new conversation; messages land on the wrong row.
+  //      Putting ``urlMatch`` first eliminates the race entirely: when
+  //      the URL says we're on chat ``B``, the runtime targets ``B``
+  //      from the very first render, regardless of stale store state.
+  //   2. ``sticky`` — for non-chat URLs (``/spaces``, ``/tasks`` …)
+  //      ``urlMatch`` is ``undefined``. ``sticky`` keeps the popout
+  //      chat "live" while the user browses elsewhere.
+  //   3. ``freshIdRef.current`` — brand-new chat on ``/`` with no
+  //      sticky and no URL match. Pre-minted so the runtime's
+  //      ``threadId`` is defined from the first render (no
+  //      ``undefined → defined`` remount of assistant-ui).
+  const effectiveThreadId: string = urlMatch ?? sticky ?? freshIdRef.current;
 
   const historyAdapterFactory = useCallback<AGUIHistoryAdapterFactory>(
     (args: AGUIChatConversationFactoryArgs) =>