@vibe-forge/client 2.0.0 → 2.0.1

package/public/sw.js

@@ -0,0 +1,105 @@
+const CACHE_PREFIX = 'vibe-forge-web'
+const CACHE_VERSION = 'v1'
+const APP_CACHE = `${CACHE_PREFIX}-app-${CACHE_VERSION}`
+const STATIC_CACHE = `${CACHE_PREFIX}-static-${CACHE_VERSION}`
+const serviceWorkerGlobal = globalThis
+
+const appScopeUrl = new URL(serviceWorkerGlobal.registration.scope)
+
+const isSameOrigin = url => url.origin === serviceWorkerGlobal.location.origin
+
+const isInsideAppScope = url => url.href.startsWith(appScopeUrl.href)
+
+const isStaticAssetRequest = url => (
+  url.pathname.includes('/assets/') ||
+  url.pathname.endsWith('/favicon.svg') ||
+  url.pathname.endsWith('/manifest.webmanifest') ||
+  url.pathname.endsWith('/pwa-icon-192.png') ||
+  url.pathname.endsWith('/pwa-icon-512.png')
+)
+
+const pruneOldCaches = async () => {
+  const cacheNames = await caches.keys()
+  await Promise.all(
+    cacheNames
+      .filter(name => name.startsWith(CACHE_PREFIX) && name !== APP_CACHE && name !== STATIC_CACHE)
+      .map(name => caches.delete(name))
+  )
+}
+
+const cacheAppShell = async () => {
+  const cache = await caches.open(APP_CACHE)
+  try {
+    await cache.add(new Request(appScopeUrl.href, { cache: 'reload' }))
+  } catch {
+    // Installing should still succeed if the first shell refresh races the network.
+  }
+}
+
+const networkFirstNavigation = async request => {
+  const cache = await caches.open(APP_CACHE)
+  try {
+    const response = await fetch(request)
+    if (response.ok) {
+      await cache.put(appScopeUrl.href, response.clone())
+    }
+    return response
+  } catch (error) {
+    const cached = await cache.match(appScopeUrl.href)
+    if (cached != null) {
+      return cached
+    }
+    throw error
+  }
+}
+
+const staleWhileRevalidate = async request => {
+  const cache = await caches.open(STATIC_CACHE)
+  const cached = await cache.match(request)
+  const networkResponse = fetch(request)
+    .then(async response => {
+      if (response.ok) {
+        await cache.put(request, response.clone())
+      }
+      return response
+    })
+    .catch(error => {
+      if (cached != null) {
+        return cached
+      }
+      throw error
+    })
+
+  return cached ?? networkResponse
+}
+
+serviceWorkerGlobal.addEventListener('install', event => {
+  event.waitUntil(
+    cacheAppShell()
+      .then(() => serviceWorkerGlobal.skipWaiting())
+  )
+})
+
+serviceWorkerGlobal.addEventListener('activate', event => {
+  event.waitUntil(
+    pruneOldCaches()
+      .then(() => serviceWorkerGlobal.clients.claim())
+  )
+})
+
+serviceWorkerGlobal.addEventListener('fetch', event => {
+  const { request } = event
+  if (request.method !== 'GET') return
+
+  const url = new URL(request.url)
+  if (!isSameOrigin(url) || !isInsideAppScope(url)) return
+
+  if (request.mode === 'navigate') {
+    event.respondWith(networkFirstNavigation(request))
+    return
+  }
+
+  if (isStaticAssetRequest(url)) {
+    event.respondWith(staleWhileRevalidate(request))
+  }
+})

package/src/App.tsx

@@ -1,12 +1,14 @@
 import { ConfigProvider } from 'antd'
 
+import { AuthGate } from '#~/components/auth/AuthGate'
 import { AppShell } from '#~/components/layout/AppShell'
+import { ServerConnectionGate } from '#~/components/server-connection/ServerConnectionGate'
 import { useAppPreferences } from '#~/hooks/use-app-preferences'
 import { useSessionSubscription } from '#~/hooks/use-session-subscription.js'
 import { useSidebarNavigation } from '#~/hooks/use-sidebar-navigation'
 import { AppRoutes } from '#~/routes/AppRoutes'
 
-export default function App() {
+function AuthenticatedApp() {
   useSessionSubscription()
   const { isDarkMode, themeConfig } = useAppPreferences()
   const sidebarNavigation = useSidebarNavigation()
@@ -26,3 +28,13 @@ export default function App() {
     </ConfigProvider>
   )
 }
+
+export default function App() {
+  return (
+    <ServerConnectionGate>
+      <AuthGate>
+        <AuthenticatedApp />
+      </AuthGate>
+    </ServerConnectionGate>
+  )
+}

package/src/api/README.md

@@ -11,6 +11,7 @@
 - `projects.ts`: 项目列表与创建
 - `sessions.ts`: 会话与消息
 - `types.ts`: 跨模块共享的响应类型
+- `worktree-environments.ts`: worktree 环境脚本管理
 
 ## 新增或修改 API 的标准流程
 

package/src/api/adapters.ts

@@ -0,0 +1,63 @@
+import type {
+  AdapterAccountDetailResult,
+  AdapterAccountsResult,
+  AdapterManageAccountOptions,
+  AdapterManageAccountResult
+} from '@vibe-forge/types'
+
+import { createApiUrl, fetchApiJson, jsonHeaders } from './base'
+
+export async function getAdapterAccounts(
+  adapter: string,
+  options: {
+    model?: string
+    account?: string
+    refresh?: boolean
+  } = {}
+): Promise<AdapterAccountsResult> {
+  const url = createApiUrl(`/api/adapters/${encodeURIComponent(adapter)}/accounts`)
+  if (options.model != null && options.model.trim() !== '') {
+    url.searchParams.set('model', options.model)
+  }
+  if (options.account != null && options.account.trim() !== '') {
+    url.searchParams.set('account', options.account)
+  }
+  if (options.refresh === true) {
+    url.searchParams.set('refresh', 'true')
+  }
+  return fetchApiJson<AdapterAccountsResult>(url)
+}
+
+export async function getAdapterAccountDetail(
+  adapter: string,
+  account: string,
+  options: {
+    model?: string
+    refresh?: boolean
+  } = {}
+): Promise<AdapterAccountDetailResult> {
+  const url = createApiUrl(`/api/adapters/${encodeURIComponent(adapter)}/accounts/${encodeURIComponent(account)}`)
+  if (options.model != null && options.model.trim() !== '') {
+    url.searchParams.set('model', options.model)
+  }
+  if (options.refresh === true) {
+    url.searchParams.set('refresh', 'true')
+  }
+  return fetchApiJson<AdapterAccountDetailResult>(url)
+}
+
+export async function manageAdapterAccount(
+  adapter: string,
+  options: Pick<AdapterManageAccountOptions, 'action' | 'account' | 'model' | 'refresh'>,
+  requestOptions?: Pick<RequestInit, 'signal'>
+): Promise<AdapterManageAccountResult> {
+  return fetchApiJson<AdapterManageAccountResult>(
+    createApiUrl(`/api/adapters/${encodeURIComponent(adapter)}/accounts/actions`),
+    {
+      method: 'POST',
+      headers: jsonHeaders,
+      body: JSON.stringify(options),
+      ...requestOptions
+    }
+  )
+}

package/src/api/auth-token.ts

@@ -0,0 +1,51 @@
+import { getServerBaseUrl } from '#~/runtime-config'
+import {
+  clearAuthTokenForServerUrl,
+  getAuthTokenForServerUrl,
+  setAuthTokenForServerUrl
+} from '#~/server-connection-history'
+
+const LEGACY_AUTH_TOKEN_STORAGE_KEY = 'vf_auth_token'
+
+const getStorage = () => {
+  try {
+    return globalThis.localStorage
+  } catch {
+    return undefined
+  }
+}
+
+export const getAuthToken = () => {
+  const serverUrl = getServerBaseUrl()
+  const scopedToken = getAuthTokenForServerUrl(serverUrl)?.trim()
+  if (scopedToken != null && scopedToken !== '') return scopedToken
+
+  const legacyToken = getStorage()?.getItem(LEGACY_AUTH_TOKEN_STORAGE_KEY)?.trim()
+  if (legacyToken == null || legacyToken === '') return undefined
+
+  setAuthTokenForServerUrl(serverUrl, legacyToken)
+  getStorage()?.removeItem(LEGACY_AUTH_TOKEN_STORAGE_KEY)
+  return legacyToken
+}
+
+export const setAuthToken = (token: string) => {
+  const normalized = token.trim()
+  if (normalized === '') {
+    return
+  }
+  setAuthTokenForServerUrl(getServerBaseUrl(), normalized)
+  getStorage()?.removeItem(LEGACY_AUTH_TOKEN_STORAGE_KEY)
+}
+
+export const clearAuthToken = () => {
+  clearAuthTokenForServerUrl(getServerBaseUrl())
+  getStorage()?.removeItem(LEGACY_AUTH_TOKEN_STORAGE_KEY)
+}
+
+export const applyAuthHeader = (headers: Headers) => {
+  const token = getAuthToken()
+  if (token == null || headers.has('Authorization')) {
+    return
+  }
+  headers.set('Authorization', `Bearer ${token}`)
+}

package/src/api/auth.ts

@@ -0,0 +1,46 @@
+import { clearAuthToken } from './auth-token'
+import { fetchApiJson, fetchApiJsonOrThrow, jsonHeaders } from './base'
+
+export interface AuthStatus {
+  enabled: boolean
+  authenticated: boolean
+  usernames: string[]
+  passwordSource: 'config' | 'env' | 'generated'
+  passwordFilePath?: string
+  version?: string
+  token?: string
+}
+
+export interface LoginInput {
+  username: string
+  password: string
+  rememberDevice: boolean
+  returnToken?: boolean
+}
+
+export const getAuthStatus = () => fetchApiJson<AuthStatus>('/api/auth/status')
+
+export const login = (input: LoginInput) => (
+  fetchApiJsonOrThrow<AuthStatus>(
+    '/api/auth/login',
+    {
+      method: 'POST',
+      headers: jsonHeaders,
+      body: JSON.stringify(input)
+    },
+    '[api] login failed:'
+  )
+)
+
+export const logout = async () => {
+  const result = await fetchApiJsonOrThrow<{ ok: boolean }>(
+    '/api/auth/logout',
+    {
+      method: 'POST',
+      headers: jsonHeaders
+    },
+    '[api] logout failed:'
+  )
+  clearAuthToken()
+  return result
+}

package/src/api/automation.ts

@@ -1,3 +1,5 @@
+import type { EffortLevel, GitBranchKind, SessionPermissionMode } from '@vibe-forge/types'
+
 import { createApiUrl, fetchApiJson, jsonHeaders } from './base'
 
 export interface AutomationTrigger {
@@ -12,6 +14,14 @@ export interface AutomationTask {
   id: string
   title: string
   prompt: string
+  model?: string | null
+  adapter?: string | null
+  effort?: EffortLevel | null
+  permissionMode?: SessionPermissionMode | null
+  createWorktree?: boolean | null
+  branchName?: string | null
+  branchKind?: GitBranchKind | null
+  branchMode?: 'checkout' | 'create' | null
 }
 
 export interface AutomationRule {

package/src/api/base.ts

@@ -1,33 +1,26 @@
-import { getServerHostEnv, getServerPortEnv } from '#~/runtime-config.js'
+import { createServerUrl, getServerBaseUrl } from '#~/runtime-config.js'
 
-const DEFAULT_SERVER_PORT = '8787'
-const SERVER_HOST_ENV = getServerHostEnv()
-const SERVER_PORT_ENV = getServerPortEnv()
+import { applyAuthHeader } from './auth-token'
 
 export const jsonHeaders = { 'Content-Type': 'application/json' } as const
 
 export const getServerHost = () => {
-  if (SERVER_HOST_ENV != null && SERVER_HOST_ENV !== '') {
-    return SERVER_HOST_ENV
-  }
-  return window.location.hostname
+  return new URL(getServerUrl()).hostname
 }
 
 export const getServerPort = () => {
-  if (SERVER_PORT_ENV != null && SERVER_PORT_ENV !== '') {
-    return SERVER_PORT_ENV
-  }
-  return DEFAULT_SERVER_PORT
+  const { port, protocol } = new URL(getServerUrl())
+  if (port !== '') return port
+  return protocol === 'https:' ? '443' : '80'
 }
 
-export const getServerUrl = () => `http://${getServerHost()}:${getServerPort()}`
+export const getServerUrl = () => getServerBaseUrl()
 
 export const buildApiUrl = (path: string) => {
   if (path.startsWith('http://') || path.startsWith('https://')) {
     return path
   }
-  const normalized = path.startsWith('/') ? path : `/${path}`
-  return `${getServerUrl()}${normalized}`
+  return createServerUrl(path)
 }
 
 export const createApiUrl = (path: string) => new URL(buildApiUrl(path))
@@ -146,9 +139,19 @@ export const getApiErrorMessage = (error: unknown, fallback: string) => {
   return fallback
 }
 
+const createRequestInit = (init?: RequestInit): RequestInit => {
+  const headers = new Headers(init?.headers)
+  applyAuthHeader(headers)
+  return {
+    ...init,
+    credentials: init?.credentials ?? 'include',
+    headers
+  }
+}
+
 export async function fetchApiJson<T>(pathOrUrl: string | URL, init?: RequestInit): Promise<T> {
   const url = typeof pathOrUrl === 'string' ? buildApiUrl(pathOrUrl) : pathOrUrl.toString()
-  const res = await fetch(url, init)
+  const res = await fetch(url, createRequestInit(init))
   return unwrapApiResponse<T>(res)
 }
 
@@ -158,6 +161,6 @@ export async function fetchApiJsonOrThrow<T>(
   errorLabel: string
 ): Promise<T> {
   const url = typeof pathOrUrl === 'string' ? buildApiUrl(pathOrUrl) : pathOrUrl.toString()
-  const res = await fetch(url, init)
+  const res = await fetch(url, createRequestInit(init))
   return unwrapApiResponse<T>(res, errorLabel)
 }

package/src/api/config.ts

@@ -1,5 +1,5 @@
 import type { ConfigSource } from '@vibe-forge/core'
-import type { ConfigResponse } from '@vibe-forge/types'
+import type { ConfigResponse, ConfigSchemaResponse } from '@vibe-forge/types'
 
 import { fetchApiJson, fetchApiJsonOrThrow, jsonHeaders } from './base'
 import type { ApiOkResponse } from './types'
@@ -8,6 +8,10 @@ export async function getConfig(): Promise<ConfigResponse> {
   return fetchApiJson<ConfigResponse>('/api/config')
 }
 
+export async function getConfigSchema(): Promise<ConfigSchemaResponse> {
+  return fetchApiJson<ConfigSchemaResponse>('/api/config/schema')
+}
+
 export async function updateConfig(
   source: ConfigSource,
   section: string,

package/src/api/knowledge.ts

@@ -21,6 +21,15 @@ export interface EntitySummary {
   rules: string[]
 }
 
+export interface WorkspaceSummary {
+  id: string
+  name: string
+  description: string
+  path: string
+  cwd: string
+  pattern?: string
+}
+
 export interface RuleSummary {
   id: string
   name: string
@@ -29,6 +38,15 @@ export interface RuleSummary {
   globs?: string[]
 }
 
+export interface SkillSummary {
+  id: string
+  name: string
+  description: string
+  always: boolean
+  instancePath?: string
+  source: 'project' | 'plugin' | 'home'
+}
+
 export interface SpecDetail extends SpecSummary {
   body: string
 }
@@ -41,14 +59,49 @@ export interface RuleDetail extends RuleSummary {
   body: string
 }
 
+export interface SkillDetail extends SkillSummary {
+  body: string
+}
+
 export async function listSpecs(): Promise<{ specs: SpecSummary[] }> {
   return fetchApiJson<{ specs: SpecSummary[] }>('/api/ai/specs')
 }
 
+export async function listSkills(): Promise<{ skills: SkillSummary[] }> {
+  return fetchApiJson<{ skills: SkillSummary[] }>('/api/ai/skills')
+}
+
+export async function createSkill(params: {
+  name: string
+  description?: string
+  body?: string
+}): Promise<{ skill: SkillDetail }> {
+  return fetchApiJson<{ skill: SkillDetail }>('/api/ai/skills', {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify(params)
+  })
+}
+
+export async function importSkillArchive(file: File): Promise<{ fileCount: number; targetDir: string }> {
+  return fetchApiJson<{ fileCount: number; targetDir: string }>('/api/ai/skills/import', {
+    method: 'POST',
+    headers: {
+      'Content-Type': file.type || 'application/octet-stream',
+      'x-file-name': encodeURIComponent(file.name)
+    },
+    body: file
+  })
+}
+
 export async function listEntities(): Promise<{ entities: EntitySummary[] }> {
   return fetchApiJson<{ entities: EntitySummary[] }>('/api/ai/entities')
 }
 
+export async function listWorkspaces(): Promise<{ workspaces: WorkspaceSummary[] }> {
+  return fetchApiJson<{ workspaces: WorkspaceSummary[] }>('/api/ai/workspaces')
+}
+
 export async function listRules(): Promise<{ rules: RuleSummary[] }> {
   return fetchApiJson<{ rules: RuleSummary[] }>('/api/ai/rules')
 }
@@ -70,3 +123,9 @@ export async function getRuleDetail(path: string): Promise<{ rule: RuleDetail }>
   url.searchParams.set('path', path)
   return fetchApiJson<{ rule: RuleDetail }>(url)
 }
+
+export async function getSkillDetail(path: string): Promise<{ skill: SkillDetail }> {
+  const url = createApiUrl('/api/ai/skills/detail')
+  url.searchParams.set('path', path)
+  return fetchApiJson<{ skill: SkillDetail }>(url)
+}

package/src/api/sessions.ts

@@ -1,9 +1,9 @@
 import type { ChatMessageContent, Session, SessionMessageQueueState, SessionQueuedMessageMode } from '@vibe-forge/core'
-import type { GitBranchKind, SessionWorkspace } from '@vibe-forge/types'
+import type { GitBranchKind, SessionPromptType, SessionWorkspace } from '@vibe-forge/types'
 
 import { createApiUrl, fetchApiJson, fetchApiJsonOrThrow, jsonHeaders } from './base'
 import type { ApiOkResponse, ApiRemoveResponse, SessionMessagesResponse } from './types'
-import type { WorkspaceTreeEntry } from './workspace'
+import type { WorkspaceFileContent, WorkspaceTreeEntry } from './workspace'
 
 export async function listSessions(
   filter: 'active' | 'archived' | 'all' = 'active'
@@ -21,13 +21,16 @@ export async function createSession(
     start?: boolean
     parentSessionId?: string
     id?: string
-    promptType?: 'spec' | 'entity'
+    promptType?: SessionPromptType
     promptName?: string
     effort?: 'low' | 'medium' | 'high' | 'max'
     permissionMode?: 'default' | 'acceptEdits' | 'plan' | 'dontAsk' | 'bypassPermissions'
     adapter?: string
+    account?: string
+    updateSkills?: boolean
     workspace?: {
       createWorktree?: boolean
+      worktreeEnvironment?: string
       branch?: {
         name: string
         kind?: GitBranchKind
@@ -52,6 +55,8 @@ export async function createSession(
       effort: options?.effort,
       permissionMode: options?.permissionMode,
       adapter: options?.adapter,
+      account: options?.account,
+      updateSkills: options?.updateSkills,
       workspace: options?.workspace
     })
   })
@@ -133,6 +138,33 @@ export async function listSessionWorkspaceTree(
   }>(url)
 }
 
+export async function readSessionWorkspaceFile(
+  id: string,
+  path: string
+): Promise<WorkspaceFileContent> {
+  const url = createApiUrl(`/api/sessions/${id}/workspace/file`)
+  url.searchParams.set('path', path)
+  return fetchApiJson<WorkspaceFileContent>(url)
+}
+
+export function getSessionWorkspaceResourceUrl(id: string, path: string) {
+  const url = createApiUrl(`/api/sessions/${id}/workspace/resource`)
+  url.searchParams.set('path', path)
+  return url.toString()
+}
+
+export async function updateSessionWorkspaceFile(
+  id: string,
+  path: string,
+  content: string
+): Promise<WorkspaceFileContent> {
+  return fetchApiJson<WorkspaceFileContent>(`/api/sessions/${id}/workspace/file`, {
+    method: 'PUT',
+    headers: jsonHeaders,
+    body: JSON.stringify({ path, content })
+  })
+}
+
 export async function respondSessionInteraction(
   sessionId: string,
   interactionId: string,