@vibe-forge/client 2.0.0 → 3.0.0-alpha.0

package/src/runtime-config.ts

@@ -1,10 +1,17 @@
 export type RuntimeEnv = Partial<{
+  __VF_PROJECT_AI_SERVER_BASE_URL__: string
   __VF_PROJECT_AI_SERVER_HOST__: string
   __VF_PROJECT_AI_SERVER_PORT__: string
   __VF_PROJECT_AI_SERVER_WS_PATH__: string
+  __VF_PROJECT_AI_CLIENT_MODE__: string
   __VF_PROJECT_AI_CLIENT_BASE__: string
+  __VF_PROJECT_AI_CLIENT_VERSION__: string
+  __VF_PROJECT_AI_CLIENT_COMMIT_HASH__: string
 }>
 
+export const SERVER_BASE_URL_STORAGE_KEY = 'vf_server_base_url'
+export const SERVER_CONNECTION_PICKER_STORAGE_KEY = 'vf_server_connection_picker_requested'
+
 export const resolveDevDocumentTitle = (
   baseTitle: string,
   input: {
@@ -57,6 +64,95 @@ const normalizePath = (value?: string) => {
   return next
 }
 
+const normalizeServerHost = (value?: string) => {
+  const next = value?.trim()
+  if (next == null || next === '' || next === '0.0.0.0' || next === '::' || next === '[::]') {
+    return undefined
+  }
+  return next
+}
+
+const hasUrlProtocol = (value: string) => /^[a-z][a-z\d+.-]*:\/\//i.test(value)
+
+const getStorage = () => {
+  try {
+    return globalThis.localStorage
+  } catch {
+    return undefined
+  }
+}
+
+const getBrowserProtocol = () => (
+  globalThis.location?.protocol === 'https:' ? 'https' : 'http'
+)
+
+const getClientMode = () => (
+  pickNonEmptyValue(
+    getRuntimeEnv().__VF_PROJECT_AI_CLIENT_MODE__,
+    import.meta.env.__VF_PROJECT_AI_CLIENT_MODE__,
+    import.meta.env.__VF_PROJECT_AI_CLIENT_DEPLOY_MODE__
+  )?.trim().toLowerCase()
+)
+
+export const normalizeServerBaseUrl = (value?: string) => {
+  const trimmed = value?.trim() ?? ''
+  if (trimmed === '') {
+    return undefined
+  }
+
+  const rawUrl = hasUrlProtocol(trimmed) ? trimmed : `${getBrowserProtocol()}://${trimmed}`
+  try {
+    const url = new URL(rawUrl)
+    if (url.protocol !== 'http:' && url.protocol !== 'https:') {
+      return undefined
+    }
+    url.hash = ''
+    url.search = ''
+    return url.toString().replace(/\/$/, '')
+  } catch {
+    return undefined
+  }
+}
+
+export const createServerUrlFromBase = (baseUrl: string, path: string) => {
+  const normalizedBaseUrl = normalizeServerBaseUrl(baseUrl)
+  if (normalizedBaseUrl == null) {
+    throw new Error('Invalid server base URL')
+  }
+
+  const relativePath = path.replace(/^\/+/, '')
+  return new URL(relativePath, `${normalizedBaseUrl}/`).toString()
+}
+
+export const getStoredServerBaseUrl = () => (
+  normalizeServerBaseUrl(getStorage()?.getItem(SERVER_BASE_URL_STORAGE_KEY) ?? undefined)
+)
+
+export const setStoredServerBaseUrl = (value: string) => {
+  const normalized = normalizeServerBaseUrl(value)
+  if (normalized == null) {
+    return undefined
+  }
+  getStorage()?.setItem(SERVER_BASE_URL_STORAGE_KEY, normalized)
+  return normalized
+}
+
+export const clearStoredServerBaseUrl = () => {
+  getStorage()?.removeItem(SERVER_BASE_URL_STORAGE_KEY)
+}
+
+export const isStandaloneClientMode = () => {
+  const mode = getClientMode()
+  return mode === 'standalone' || mode === 'independent'
+}
+
+export const isDesktopClientMode = () => getClientMode() === 'desktop'
+
+export const isServerConnectionManagedClientMode = () => {
+  const mode = getClientMode()
+  return mode === 'standalone' || mode === 'independent' || mode === 'desktop'
+}
+
 export const getRuntimeEnv = (): RuntimeEnv => getGlobalRuntimeEnv() ?? {}
 
 export const resolveClientBase = (...values: Array<string | undefined>) => (
@@ -73,14 +169,71 @@ export const getClientBase = () => (
 )
 
 export const getServerHostEnv = () =>
-  getRuntimeEnv().__VF_PROJECT_AI_SERVER_HOST__ ??
-    import.meta.env.__VF_PROJECT_AI_SERVER_HOST__
+  normalizeServerHost(
+    getRuntimeEnv().__VF_PROJECT_AI_SERVER_HOST__ ??
+      import.meta.env.__VF_PROJECT_AI_SERVER_HOST__
+  )
 
 export const getServerPortEnv = () =>
   getRuntimeEnv().__VF_PROJECT_AI_SERVER_PORT__ ??
     import.meta.env.__VF_PROJECT_AI_SERVER_PORT__
 
+export const getConfiguredServerBaseUrl = () => {
+  const configuredServerBaseUrl = normalizeServerBaseUrl(
+    getRuntimeEnv().__VF_PROJECT_AI_SERVER_BASE_URL__ ??
+      import.meta.env.__VF_PROJECT_AI_SERVER_BASE_URL__
+  )
+  if (configuredServerBaseUrl != null) {
+    return configuredServerBaseUrl
+  }
+
+  const serverHost = getServerHostEnv()
+  const serverPort = getServerPortEnv()?.trim()
+  if (serverHost == null || serverPort == null || serverPort === '') {
+    return undefined
+  }
+
+  return normalizeServerBaseUrl(`${serverHost}:${serverPort}`)
+}
+
+export const isServerConnectionPickerRequested = () => (
+  getStorage()?.getItem(SERVER_CONNECTION_PICKER_STORAGE_KEY) === 'true'
+)
+
+export const requestServerConnectionPicker = (
+  { clearCurrentServer = false }: { clearCurrentServer?: boolean } = {}
+) => {
+  if (clearCurrentServer) {
+    clearStoredServerBaseUrl()
+  }
+  getStorage()?.setItem(SERVER_CONNECTION_PICKER_STORAGE_KEY, 'true')
+}
+
+export const clearServerConnectionPickerRequest = () => {
+  getStorage()?.removeItem(SERVER_CONNECTION_PICKER_STORAGE_KEY)
+}
+
 export const getServerWsPath = () =>
   normalizePath(
     getRuntimeEnv().__VF_PROJECT_AI_SERVER_WS_PATH__ ?? import.meta.env.__VF_PROJECT_AI_SERVER_WS_PATH__
   )
+
+export const getServerBaseUrl = () => {
+  if (isServerConnectionManagedClientMode()) {
+    const storedServerBaseUrl = getStoredServerBaseUrl()
+    if (storedServerBaseUrl != null) {
+      return storedServerBaseUrl
+    }
+  }
+
+  const configuredServerBaseUrl = getConfiguredServerBaseUrl()
+  if (configuredServerBaseUrl != null) {
+    return configuredServerBaseUrl
+  }
+
+  const serverHost = getServerHostEnv() ?? globalThis.location?.hostname ?? 'localhost'
+  const serverPort = getServerPortEnv() ?? '8787'
+  return normalizeServerBaseUrl(`${serverHost}:${serverPort}`) ?? `${getBrowserProtocol()}://localhost:8787`
+}
+
+export const createServerUrl = (path: string) => createServerUrlFromBase(getServerBaseUrl(), path)

package/src/server-connection-history.ts

@@ -0,0 +1,179 @@
+import { normalizeServerBaseUrl } from '#~/runtime-config'
+
+export const SERVER_BASE_URL_HISTORY_STORAGE_KEY = 'vf_server_base_url_history'
+
+export interface ServerConnectionProfile {
+  serverUrl: string
+  alias?: string
+  description?: string
+  authToken?: string
+  serverVersion?: string
+  createdAt: number
+  lastConnectedAt: number
+}
+
+export interface ServerConnectionProfileDetails {
+  alias?: string
+  description?: string
+}
+
+const getStorage = () => {
+  try {
+    return globalThis.localStorage
+  } catch {
+    return undefined
+  }
+}
+
+const normalizeOptionalText = (value: unknown) => {
+  const normalized = typeof value === 'string' ? value.trim() : ''
+  return normalized === '' ? undefined : normalized
+}
+
+const normalizeProfile = (value: unknown, fallbackTime: number): ServerConnectionProfile | undefined => {
+  if (typeof value === 'string') {
+    const serverUrl = normalizeServerBaseUrl(value)
+    return serverUrl == null ? undefined : {
+      serverUrl,
+      createdAt: fallbackTime,
+      lastConnectedAt: fallbackTime
+    }
+  }
+  if (value == null || typeof value !== 'object' || Array.isArray(value)) return undefined
+
+  const record = value as Record<string, unknown>
+  const serverUrl = normalizeServerBaseUrl(record.serverUrl as string | undefined)
+  if (serverUrl == null) return undefined
+
+  const createdAt = typeof record.createdAt === 'number' ? record.createdAt : fallbackTime
+  const lastConnectedAt = typeof record.lastConnectedAt === 'number' ? record.lastConnectedAt : createdAt
+  const alias = normalizeOptionalText(record.alias)
+  const description = normalizeOptionalText(record.description)
+  const authToken = normalizeOptionalText(record.authToken)
+  const serverVersion = normalizeOptionalText(record.serverVersion)
+  return {
+    serverUrl,
+    createdAt,
+    lastConnectedAt,
+    ...(alias != null ? { alias } : {}),
+    ...(description != null ? { description } : {}),
+    ...(authToken != null ? { authToken } : {}),
+    ...(serverVersion != null ? { serverVersion } : {})
+  }
+}
+
+const sortProfiles = (profiles: ServerConnectionProfile[]) => (
+  [...profiles].sort((left, right) => right.lastConnectedAt - left.lastConnectedAt)
+)
+
+const saveProfiles = (profiles: ServerConnectionProfile[]) => {
+  const normalizedProfiles = sortProfiles(profiles)
+  getStorage()?.setItem(SERVER_BASE_URL_HISTORY_STORAGE_KEY, JSON.stringify(normalizedProfiles))
+  return normalizedProfiles
+}
+
+export const getServerConnectionProfiles = () => {
+  const raw = getStorage()?.getItem(SERVER_BASE_URL_HISTORY_STORAGE_KEY)
+  if (raw == null || raw.trim() === '') return []
+
+  try {
+    const parsed = JSON.parse(raw) as unknown
+    if (!Array.isArray(parsed)) return []
+
+    const profileByUrl = new Map<string, ServerConnectionProfile>()
+    const fallbackTime = Date.now()
+    for (const item of parsed) {
+      const profile = normalizeProfile(item, fallbackTime)
+      if (profile == null || profileByUrl.has(profile.serverUrl)) continue
+      profileByUrl.set(profile.serverUrl, profile)
+    }
+    return sortProfiles(Array.from(profileByUrl.values()))
+  } catch {
+    return []
+  }
+}
+
+export const getRecentServerBaseUrls = () => (
+  getServerConnectionProfiles().map(profile => profile.serverUrl)
+)
+
+export const rememberServerBaseUrl = (value: string, details: { serverVersion?: string } = {}) => {
+  const serverUrl = normalizeServerBaseUrl(value)
+  if (serverUrl == null) return getServerConnectionProfiles()
+
+  const now = Date.now()
+  const profiles = getServerConnectionProfiles()
+  const existing = profiles.find(profile => profile.serverUrl === serverUrl)
+  const nextProfile: ServerConnectionProfile = {
+    ...existing,
+    serverUrl,
+    createdAt: existing?.createdAt ?? now,
+    lastConnectedAt: now,
+    ...(normalizeOptionalText(details.serverVersion) != null
+      ? { serverVersion: normalizeOptionalText(details.serverVersion) }
+      : {})
+  }
+  return saveProfiles([
+    nextProfile,
+    ...profiles.filter(profile => profile.serverUrl !== serverUrl)
+  ])
+}
+
+export const updateServerConnectionProfile = (serverUrl: string, details: ServerConnectionProfileDetails) => {
+  const normalizedServerUrl = normalizeServerBaseUrl(serverUrl)
+  if (normalizedServerUrl == null) return getServerConnectionProfiles()
+
+  const now = Date.now()
+  const profiles = getServerConnectionProfiles()
+  const existing = profiles.find(profile => profile.serverUrl === normalizedServerUrl)
+  const alias = normalizeOptionalText(details.alias)
+  const description = normalizeOptionalText(details.description)
+  const { alias: _alias, description: _description, ...existingProfile } = existing ?? {}
+  return saveProfiles([
+    {
+      ...existingProfile,
+      serverUrl: normalizedServerUrl,
+      createdAt: existing?.createdAt ?? now,
+      lastConnectedAt: existing?.lastConnectedAt ?? now,
+      ...(alias != null ? { alias } : {}),
+      ...(description != null ? { description } : {})
+    },
+    ...profiles.filter(profile => profile.serverUrl !== normalizedServerUrl)
+  ])
+}
+
+export const removeServerConnectionProfile = (serverUrl: string) => {
+  const normalizedServerUrl = normalizeServerBaseUrl(serverUrl)
+  if (normalizedServerUrl == null) return getServerConnectionProfiles()
+  return saveProfiles(getServerConnectionProfiles().filter(profile => profile.serverUrl !== normalizedServerUrl))
+}
+
+export const getAuthTokenForServerUrl = (serverUrl: string) => (
+  getServerConnectionProfiles().find(profile => profile.serverUrl === normalizeServerBaseUrl(serverUrl))
+    ?.authToken
+)
+
+export const setAuthTokenForServerUrl = (serverUrl: string, token: string) => {
+  const normalizedToken = token.trim()
+  if (normalizedToken === '') return
+
+  const profiles = rememberServerBaseUrl(serverUrl)
+  const normalizedServerUrl = normalizeServerBaseUrl(serverUrl)
+  saveProfiles(
+    profiles.map(profile =>
+      profile.serverUrl === normalizedServerUrl ? { ...profile, authToken: normalizedToken } : profile
+    )
+  )
+}
+
+export const clearAuthTokenForServerUrl = (serverUrl: string) => {
+  const normalizedServerUrl = normalizeServerBaseUrl(serverUrl)
+  if (normalizedServerUrl == null) return getServerConnectionProfiles()
+  return saveProfiles(
+    getServerConnectionProfiles().map(profile => {
+      if (profile.serverUrl !== normalizedServerUrl) return profile
+      const { authToken: _authToken, ...nextProfile } = profile
+      return nextProfile
+    })
+  )
+}

package/src/store/index.ts

@@ -18,8 +18,156 @@ export const activeSessionIdAtom = atom<string | undefined>(undefined)
 
 // 主题模式: 'light' | 'dark' | 'system'
 export type ThemeMode = 'light' | 'dark' | 'system'
-export const themeAtom = atom<ThemeMode>(
-  (localStorage.getItem('theme') as ThemeMode) || 'system'
+
+const THEME_STORAGE_KEY = 'theme'
+
+const isThemeMode = (value: string): value is ThemeMode => {
+  return value === 'light' || value === 'dark' || value === 'system'
+}
+
+const getStoredThemeMode = (): ThemeMode => {
+  try {
+    const raw = localStorage.getItem(THEME_STORAGE_KEY)
+    if (raw != null && isThemeMode(raw)) {
+      return raw
+    }
+  } catch {}
+
+  return 'system'
+}
+
+const themeBaseAtom = atom<ThemeMode>(getStoredThemeMode())
+
+export const themeAtom = atom(
+  get => get(themeBaseAtom),
+  (_get, set, value: ThemeMode) => {
+    const nextValue = isThemeMode(value)
+      ? value
+      : 'system'
+
+    set(themeBaseAtom, nextValue)
+
+    try {
+      localStorage.setItem(THEME_STORAGE_KEY, nextValue)
+    } catch {}
+  }
 )
 
-export const showAnnouncementsAtom = atom(true)
+const getStoredBoolean = (key: string, defaultValue: boolean) => {
+  try {
+    const raw = localStorage.getItem(key)
+    if (raw === 'true') return true
+    if (raw === 'false') return false
+  } catch {}
+
+  return defaultValue
+}
+
+const createStoredBooleanAtom = (storageKey: string, defaultValue: boolean) => {
+  const baseAtom = atom<boolean>(getStoredBoolean(storageKey, defaultValue))
+
+  return atom(
+    get => get(baseAtom),
+    (_get, set, value: boolean) => {
+      const nextValue = value === true
+      set(baseAtom, nextValue)
+
+      try {
+        localStorage.setItem(storageKey, String(nextValue))
+      } catch {}
+    }
+  )
+}
+
+const getStoredNonNegativeInteger = (key: string, defaultValue: number) => {
+  try {
+    const raw = localStorage.getItem(key)
+    if (raw == null || raw.trim() === '') return defaultValue
+
+    const parsed = Number(raw)
+    if (Number.isInteger(parsed) && parsed >= 0) {
+      return parsed
+    }
+  } catch {}
+
+  return defaultValue
+}
+
+const createStoredNonNegativeIntegerAtom = (storageKey: string, defaultValue: number) => {
+  const baseAtom = atom<number>(getStoredNonNegativeInteger(storageKey, defaultValue))
+
+  return atom(
+    get => get(baseAtom),
+    (_get, set, value: number) => {
+      const nextValue = Number.isInteger(value) && value >= 0
+        ? value
+        : defaultValue
+
+      set(baseAtom, nextValue)
+
+      try {
+        localStorage.setItem(storageKey, String(nextValue))
+      } catch {}
+    }
+  )
+}
+
+export type SenderHeaderDisplayMode = 'expanded' | 'collapsed'
+
+const SENDER_HEADER_DISPLAY_STORAGE_KEY = 'vf_sender_header_default_display'
+
+const isSenderHeaderDisplayMode = (
+  value: string
+): value is SenderHeaderDisplayMode => {
+  return value === 'expanded' || value === 'collapsed'
+}
+
+const getStoredSenderHeaderDisplayMode = (): SenderHeaderDisplayMode => {
+  try {
+    const raw = localStorage.getItem(SENDER_HEADER_DISPLAY_STORAGE_KEY)
+    if (raw != null && isSenderHeaderDisplayMode(raw)) {
+      return raw
+    }
+  } catch {}
+
+  return 'expanded'
+}
+
+const senderHeaderDisplayBaseAtom = atom<SenderHeaderDisplayMode>(
+  getStoredSenderHeaderDisplayMode()
+)
+
+export const senderHeaderDisplayAtom = atom(
+  get => get(senderHeaderDisplayBaseAtom),
+  (_get, set, value: SenderHeaderDisplayMode) => {
+    const nextValue = isSenderHeaderDisplayMode(value)
+      ? value
+      : 'expanded'
+
+    set(senderHeaderDisplayBaseAtom, nextValue)
+
+    try {
+      localStorage.setItem(SENDER_HEADER_DISPLAY_STORAGE_KEY, nextValue)
+    } catch {}
+  }
+)
+
+const SHOW_ANNOUNCEMENTS_STORAGE_KEY = 'vf_show_announcements'
+const SHOW_NEW_SESSION_STARTER_LIST_STORAGE_KEY = 'vf_show_new_session_starter_list'
+const SESSION_LIST_SEARCH_THRESHOLD_STORAGE_KEY = 'vf_session_list_search_threshold'
+const DEFAULT_SESSION_LIST_SEARCH_THRESHOLD = 5
+
+export const showAnnouncementsAtom = createStoredBooleanAtom(
+  SHOW_ANNOUNCEMENTS_STORAGE_KEY,
+  true
+)
+
+export const showNewSessionStarterListAtom = createStoredBooleanAtom(
+  SHOW_NEW_SESSION_STARTER_LIST_STORAGE_KEY,
+  true
+)
+
+export const sessionListSearchThresholdAtom = createStoredNonNegativeIntegerAtom(
+  SESSION_LIST_SEARCH_THRESHOLD_STORAGE_KEY,
+  DEFAULT_SESSION_LIST_SEARCH_THRESHOLD
+)

package/src/styles/global.scss

@@ -28,6 +28,9 @@ html, body, #root, .ant-app {
 }
 
 :root {
+  --vf-visual-viewport-height: 100dvh;
+  --vf-keyboard-inset-bottom: 0px;
+
   --bg-color: #ffffff; /* 页面/主容器背景 */
   --sub-bg-color: #f6f6f6; /* 次级容器背景 */
   --sub-sub-bg-color: #e1e1e1; /* 更内层/弱化容器背景 */

package/src/utils/mobile-viewport.ts

@@ -0,0 +1,67 @@
+const KEYBOARD_VISIBLE_THRESHOLD = 80
+
+const focusableSelector = [
+  'input',
+  'textarea',
+  'select',
+  '[contenteditable="true"]',
+  '[role="textbox"]'
+].join(',')
+
+const getViewport = () => globalThis.visualViewport
+
+const getFocusedInput = () => {
+  const activeElement = document.activeElement
+  if (!(activeElement instanceof HTMLElement)) return undefined
+  return activeElement.matches(focusableSelector) ? activeElement : undefined
+}
+
+const scrollFocusedInputIntoView = () => {
+  const focusedInput = getFocusedInput()
+  if (focusedInput == null) return
+
+  focusedInput.scrollIntoView({
+    block: 'center',
+    inline: 'nearest',
+    behavior: 'auto'
+  })
+}
+
+export const setupMobileViewport = () => {
+  if (typeof window === 'undefined') return
+
+  let scrollFrame = 0
+
+  const updateViewportVars = () => {
+    const viewport = getViewport()
+    const viewportHeight = viewport?.height ?? window.innerHeight
+    const viewportOffsetTop = viewport?.offsetTop ?? 0
+    const focusedInput = getFocusedInput()
+    const keyboardInset = viewport == null || focusedInput == null
+      ? 0
+      : Math.max(0, window.innerHeight - viewportHeight - viewportOffsetTop)
+
+    document.documentElement.style.setProperty('--vf-visual-viewport-height', `${Math.round(viewportHeight)}px`)
+    document.documentElement.style.setProperty('--vf-keyboard-inset-bottom', `${Math.round(keyboardInset)}px`)
+    document.documentElement.classList.toggle('has-mobile-keyboard', keyboardInset > KEYBOARD_VISIBLE_THRESHOLD)
+  }
+
+  const scheduleFocusedInputScroll = () => {
+    window.cancelAnimationFrame(scrollFrame)
+    scrollFrame = window.requestAnimationFrame(() => {
+      updateViewportVars()
+      scrollFocusedInputIntoView()
+    })
+  }
+
+  updateViewportVars()
+
+  getViewport()?.addEventListener('resize', scheduleFocusedInputScroll)
+  getViewport()?.addEventListener('scroll', scheduleFocusedInputScroll)
+  window.addEventListener('resize', scheduleFocusedInputScroll)
+  window.addEventListener('orientationchange', scheduleFocusedInputScroll)
+  document.addEventListener('focusin', scheduleFocusedInputScroll)
+  document.addEventListener('focusout', () => {
+    window.setTimeout(updateViewportVars, 120)
+  })
+}

package/src/version-compatibility.ts

@@ -0,0 +1,37 @@
+export interface ParsedSemver {
+  major: number
+  minor: number
+  patch: number
+  prerelease?: string
+}
+
+const SEMVER_PATTERN = /^v?(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?(?:\+[0-9A-Za-z.-]+)?$/
+
+export const parseSemverVersion = (value: string | undefined): ParsedSemver | undefined => {
+  const match = value?.trim().match(SEMVER_PATTERN)
+  if (match == null) return undefined
+  return {
+    major: Number(match[1]),
+    minor: Number(match[2]),
+    patch: Number(match[3]),
+    ...(match[4] != null ? { prerelease: match[4] } : {})
+  }
+}
+
+export const areSemverVersionsCompatible = (
+  clientVersion: string | undefined,
+  serverVersion: string | undefined
+) => {
+  const client = parseSemverVersion(clientVersion)
+  const server = parseSemverVersion(serverVersion)
+  if (client == null || server == null) return false
+  if (client.prerelease != null || server.prerelease != null) {
+    return client.major === server.major &&
+      client.minor === server.minor &&
+      client.patch === server.patch &&
+      client.prerelease === server.prerelease
+  }
+  if (client.major !== server.major) return false
+  if (client.major === 0) return client.minor === server.minor
+  return true
+}

package/src/vite-env.d.ts

@@ -1,12 +1,17 @@
 /// <reference types="vite/client" />
 
 interface ImportMetaEnv {
+  readonly __VF_PROJECT_AI_SERVER_BASE_URL__: string
   readonly __VF_PROJECT_AI_SERVER_HOST__: string
   readonly __VF_PROJECT_AI_SERVER_PORT__: string
   readonly __VF_PROJECT_AI_SERVER_WS_PATH__: string
   readonly __VF_PROJECT_AI_CLIENT_HOST__: string
+  readonly __VF_PROJECT_AI_CLIENT_MODE__: string
+  readonly __VF_PROJECT_AI_CLIENT_DEPLOY_MODE__: string
   readonly __VF_PROJECT_AI_CLIENT_PORT__: string
   readonly __VF_PROJECT_AI_CLIENT_BASE__: string
+  readonly __VF_PROJECT_AI_CLIENT_VERSION__: string
+  readonly __VF_PROJECT_AI_CLIENT_COMMIT_HASH__: string
   readonly __VF_PROJECT_AI_DEV_GIT_REF__: string
 }
 
@@ -16,9 +21,13 @@ interface ImportMeta {
 
 interface Window {
   __VF_PROJECT_AI_RUNTIME_ENV__?: Partial<{
+    __VF_PROJECT_AI_SERVER_BASE_URL__: string
     __VF_PROJECT_AI_SERVER_HOST__: string
     __VF_PROJECT_AI_SERVER_PORT__: string
     __VF_PROJECT_AI_SERVER_WS_PATH__: string
+    __VF_PROJECT_AI_CLIENT_MODE__: string
     __VF_PROJECT_AI_CLIENT_BASE__: string
+    __VF_PROJECT_AI_CLIENT_VERSION__: string
+    __VF_PROJECT_AI_CLIENT_COMMIT_HASH__: string
   }>
 }