refactor: move assistant workspace install before OpenCode server start

chriswritescode-dev · chriswritescode-dev · commit 949f3a90244f · 2026-06-06T14:22:59.000-04:00
diff --git a/backend/src/index.ts b/backend/src/index.ts
@@ -45,7 +45,7 @@ import { createOpenCodeClient } from './services/opencode/client'
 import { NotificationService } from './services/notification'
 import { ScheduleRunner, ScheduleService } from './services/schedules'
 import { migrateGlobalSkills } from './services/skills'
-import { warmAssistantWorkspace } from './services/assistant-mode'
+import { installAssistantWorkspace } from './services/assistant-mode'
 import { getOpenCodeImportStatus, syncOpenCodeImport } from './services/opencode-import'
 import { OpenCodeSupervisor } from './services/opencode-supervisor'
 import { OpenCodeConfigSchema } from '@opencode-manager/shared/schemas'
@@ -263,6 +263,12 @@ try {
 
   await migrateGlobalSkills()
 
+  await installAssistantWorkspace({
+    db,
+    apiBaseUrl: `http://localhost:${PORT}/api/internal`,
+  })
+  logger.info('Assistant workspace installed')
+
   ipcServer = await createIPCServer(process.env.STORAGE_PATH || undefined)
   await gitAuthService.initialize(ipcServer, db)
   logger.info(`Git IPC server running at ${ipcServer.ipcHandlePath}`)
@@ -273,11 +279,6 @@ try {
   const openCodeStatus = await openCodeSupervisor.start()
   if (openCodeStatus.healthy) {
     logger.info(`OpenCode server running on port ${openCodeStatus.port}`)
-    void warmAssistantWorkspace({
-      db,
-      apiBaseUrl: `http://localhost:${PORT}/api/internal`,
-      openCodeClient,
-    })
   } else {
     logger.warn(`OpenCode server unavailable after startup recovery: ${openCodeStatus.lastError ?? openCodeStatus.state}`)
   }
diff --git a/backend/src/services/assistant-mode.ts b/backend/src/services/assistant-mode.ts
@@ -17,10 +17,7 @@ import { ASSISTANT_REPO_ID, ASSISTANT_REPO_PATH } from '@opencode-manager/shared
 import { getReposPath, ENV } from '@opencode-manager/shared/config/env'
 import type { Database } from 'bun:sqlite'
 import { getOrCreateInternalToken } from './internal-token'
-import type { OpenCodeClient } from './opencode/client'
-import { logger } from '../utils/logger'
 
-const ASSISTANT_WARMUP_OPENCODE_TIMEOUT_MS = 90000
 
 const ASSISTANT_MODE_DIR = ASSISTANT_REPO_PATH
 const ASSISTANT_MODE_RELATIVE_PATH = 'repos/assistant'
@@ -1080,22 +1077,12 @@ export async function getAssistantModeStatus(repo: Repo): Promise<AssistantModeS
   }
 }
 
-export async function warmAssistantWorkspace(deps: {
+export async function installAssistantWorkspace(deps: {
   db: Database
   apiBaseUrl: string
-  openCodeClient: OpenCodeClient
-}): Promise<void> {
-  try {
-    const status = await ensureAssistantMode(buildAssistantRepo(), {
-      db: deps.db,
-      apiBaseUrl: deps.apiBaseUrl,
-    })
-    await deps.openCodeClient.getJson('/api/session?limit=1&order=desc', {
-      directory: status.directory,
-      signal: AbortSignal.timeout(ASSISTANT_WARMUP_OPENCODE_TIMEOUT_MS),
-    })
-    logger.info('Assistant workspace warmed')
-  } catch (error) {
-    logger.warn('Assistant workspace warmup failed (non-fatal):', error)
-  }
+}): Promise<AssistantModeStatus> {
+  return ensureAssistantMode(buildAssistantRepo(), {
+    db: deps.db,
+    apiBaseUrl: deps.apiBaseUrl,
+  })
 }
diff --git a/backend/test/routes/repos.test.ts b/backend/test/routes/repos.test.ts
@@ -163,6 +163,8 @@ describe('Repo Routes', () => {
       const body = await res.json() as typeof mockStatus
       expect(body.repoId).toBe(1)
       expect(body.relativePath).toBe('repos/assistant')
+
+      expect(ensureAssistantMode).not.toHaveBeenCalled()
     })
   })
 
@@ -217,6 +219,17 @@ describe('Repo Routes', () => {
       })
 
       expect(res.status).toBe(200)
+
+      const body = await res.json() as typeof mockStatus
+      expect(body).toEqual(mockStatus)
+
+      expect(ensureAssistantMode).toHaveBeenCalledTimes(1)
+      expect(ensureAssistantMode).toHaveBeenCalledWith(
+        expect.objectContaining({ id: 1, localPath: 'repos/test-repo' }),
+        expect.objectContaining({ db: mockDb, apiBaseUrl: 'http://localhost:5003/api/internal' }),
+        expect.objectContaining({ overwriteAgentsMd: true }),
+      )
+
       expect(opencodeServerManager.clearStartupError).not.toHaveBeenCalled()
       expect(opencodeServerManager.restart).not.toHaveBeenCalled()
     })
diff --git a/backend/test/services/assistant-mode.test.ts b/backend/test/services/assistant-mode.test.ts
@@ -2,9 +2,8 @@ import { describe, expect, it, beforeEach, afterEach } from 'bun:test'
 import path from 'path'
 import { readFile, stat, writeFile } from 'fs/promises'
 import { Hono } from 'hono'
-import { ensureAssistantMode, getAssistantModeStatus, buildSchedulesSkill, buildReposSkill, buildSettingsSkill, buildAssistantDefaultAgentMd, buildAssistantOpenCodeConfig, buildAssistantRepo, warmAssistantWorkspace } from '../../src/services/assistant-mode'
+import { ensureAssistantMode, getAssistantModeStatus, buildSchedulesSkill, buildReposSkill, buildSettingsSkill, buildAssistantDefaultAgentMd, buildAssistantOpenCodeConfig, buildAssistantRepo, installAssistantWorkspace } from '../../src/services/assistant-mode'
 import { createTempAssistantWorkspace, createTestDb, mockRepo } from '../helpers/assistant-workspace'
-import type { OpenCodeClient } from '../../src/services/opencode/client'
 import { createInternalRoutes } from '../../src/routes/internal'
 import { ScheduleService } from '../../src/services/schedules'
 import { NotificationService } from '../../src/services/notification'
@@ -609,7 +608,7 @@ describe('buildAssistantRepo', () => {
   })
 })
 
-describe('warmAssistantWorkspace', () => {
+describe('installAssistantWorkspace', () => {
   let ws: Awaited<ReturnType<typeof createTempAssistantWorkspace>>
   let db: ReturnType<typeof createTestDb>
   const apiBaseUrl = 'http://localhost:5003/api/internal'
@@ -620,34 +619,50 @@ describe('warmAssistantWorkspace', () => {
   })
   afterEach(async () => { await ws.cleanup() })
 
-  it('provisions the workspace and triggers a bounded directory-scoped session request', async () => {
-    const getJsonCalls: Array<{ path: string; directory?: string }> = []
-    const client = {
-      getJson: async (requestPath: string, opts?: { directory?: string }) => {
-        getJsonCalls.push({ path: requestPath, directory: opts?.directory })
-        return []
-      },
-    } as unknown as OpenCodeClient
-
-    await warmAssistantWorkspace({ db, apiBaseUrl, openCodeClient: client })
+  it('provisions the assistant workspace files without contacting OpenCode', async () => {
+    const result = await installAssistantWorkspace({ db, apiBaseUrl })
 
     const opencodeJson = await readFile(path.join(ws.assistantDir, 'opencode.json'), 'utf8')
     expect(JSON.parse(opencodeJson).default_agent).toBe('assistant')
-    expect(getJsonCalls).toHaveLength(1)
-    expect(getJsonCalls[0]?.path).toBe('/api/session?limit=1&order=desc')
-    expect(getJsonCalls[0]?.directory).toBe(ws.assistantDir)
+
+    const agentsMd = await readFile(path.join(ws.assistantDir, 'AGENTS.md'), 'utf8')
+    expect(agentsMd).toContain('Assistant Mode Workspace')
+
+    const assistantAgent = await readFile(path.join(ws.assistantDir, '.opencode/agents/assistant.md'), 'utf8')
+    expect(assistantAgent).toContain('mode: primary')
+
+    expect(result.files.opencodeJson?.exists).toBe(true)
+    expect(result.files.agentsMd?.exists).toBe(true)
+    expect(result.defaultAgent?.exists).toBe(true)
   })
 
-  it('does not throw and still provisions the workspace when the session request fails', async () => {
-    const client = {
-      getJson: async () => { throw new Error('opencode unavailable') },
-    } as unknown as OpenCodeClient
+  it('is idempotent — second call does not recreate files and content is unchanged', async () => {
+    await installAssistantWorkspace({ db, apiBaseUrl })
+
+    const opencodeJsonPath = path.join(ws.assistantDir, 'opencode.json')
+    const agentsMdPath = path.join(ws.assistantDir, 'AGENTS.md')
+    const assistantAgentPath = path.join(ws.assistantDir, '.opencode/agents/assistant.md')
 
-    await expect(
-      warmAssistantWorkspace({ db, apiBaseUrl, openCodeClient: client })
-    ).resolves.toBeUndefined()
+    const firstContent = {
+      opencodeJson: await readFile(opencodeJsonPath, 'utf8'),
+      agentsMd: await readFile(agentsMdPath, 'utf8'),
+      assistantAgent: await readFile(assistantAgentPath, 'utf8'),
+    }
 
-    const opencodeJson = await stat(path.join(ws.assistantDir, 'opencode.json'))
-    expect(opencodeJson.isFile()).toBe(true)
+    const result = await installAssistantWorkspace({ db, apiBaseUrl })
+
+    const secondContent = {
+      opencodeJson: await readFile(opencodeJsonPath, 'utf8'),
+      agentsMd: await readFile(agentsMdPath, 'utf8'),
+      assistantAgent: await readFile(assistantAgentPath, 'utf8'),
+    }
+
+    expect(secondContent.opencodeJson).toBe(firstContent.opencodeJson)
+    expect(secondContent.agentsMd).toBe(firstContent.agentsMd)
+    expect(secondContent.assistantAgent).toBe(firstContent.assistantAgent)
+
+    expect(result.files.opencodeJson?.created).toBe(false)
+    expect(result.files.agentsMd?.created).toBe(false)
+    expect(result.defaultAgent?.created).toBe(false)
   })
 })
diff --git a/frontend/src/hooks/useAssistantSessionLauncher.test.tsx b/frontend/src/hooks/useAssistantSessionLauncher.test.tsx
@@ -2,18 +2,18 @@ import { renderHook, act } from '@testing-library/react'
 import { describe, it, expect, beforeEach, vi } from 'vitest'
 import { useAssistantSessionLauncher } from './useAssistantSessionLauncher'
 import { OpenCodeClient } from '@/api/opencode'
-import { initializeAssistantMode } from '@/api/repos'
+import { getAssistantModeStatus } from '@/api/repos'
 
 const mocks = vi.hoisted(() => ({
   listSessions: vi.fn(),
   listSessionsPage: vi.fn(),
   createSession: vi.fn(),
   sendPromptAsync: vi.fn(),
-  initializeAssistantMode: vi.fn(),
+  getAssistantModeStatus: vi.fn(),
 }))
 
 vi.mock('@/api/repos', () => ({
-  initializeAssistantMode: mocks.initializeAssistantMode,
+  getAssistantModeStatus: mocks.getAssistantModeStatus,
 }))
 
 vi.mock('@/api/opencode', () => ({
@@ -33,7 +33,14 @@ describe('useAssistantSessionLauncher', () => {
   beforeEach(() => {
     vi.clearAllMocks()
     localStorage.clear()
-    mocks.initializeAssistantMode.mockResolvedValue({ directory: '/assistant' })
+    mocks.getAssistantModeStatus.mockResolvedValue({
+      directory: '/assistant',
+      files: {
+        agentsMd: { path: '/assistant/AGENTS.md', exists: true, created: true },
+        opencodeJson: { path: '/assistant/.opencode.json', exists: true, created: true },
+      },
+      defaultAgent: { name: 'assistant', path: '/assistant/.opencode/agents/assistant.md', exists: true, created: true },
+    })
   })
 
   it('opens the latest root session in the assistant directory', async () => {
@@ -56,7 +63,7 @@ describe('useAssistantSessionLauncher', () => {
       await result.current.openAssistant()
     })
 
-    expect(initializeAssistantMode).toHaveBeenCalledWith(123)
+    expect(getAssistantModeStatus).toHaveBeenCalledWith(123)
     expect(OpenCodeClient).toHaveBeenCalledWith('http://localhost:5551', '/assistant')
     expect(mocks.listSessionsPage).toHaveBeenCalledWith({ limit: 25, order: 'desc' })
     expect(mocks.listSessions).not.toHaveBeenCalled()
@@ -97,8 +104,13 @@ describe('useAssistantSessionLauncher', () => {
   })
 
   it('notifies an existing assistant session when some generated updates were preserved', async () => {
-    mocks.initializeAssistantMode.mockResolvedValue({
+    mocks.getAssistantModeStatus.mockResolvedValue({
       directory: '/assistant',
+      files: {
+        agentsMd: { path: '/assistant/AGENTS.md', exists: true, created: true },
+        opencodeJson: { path: '/assistant/.opencode.json', exists: true, created: true },
+      },
+      defaultAgent: { name: 'assistant', path: '/assistant/.opencode/agents/assistant.md', exists: true, created: true },
       warnings: [
         {
           code: 'assistant-agents-md-preserved',
@@ -228,4 +240,82 @@ describe('useAssistantSessionLauncher', () => {
     expect(onNavigate).toHaveBeenCalledWith('created')
     expect(mocks.sendPromptAsync).toHaveBeenCalled()
   })
+
+  it('rejects with readiness error when agentMd is missing', async () => {
+    mocks.getAssistantModeStatus.mockResolvedValue({
+      directory: '/assistant',
+      files: {
+        agentsMd: { path: '/assistant/AGENTS.md', exists: false, created: false },
+        opencodeJson: { path: '/assistant/.opencode.json', exists: true, created: true },
+      },
+      defaultAgent: { name: 'assistant', path: '/assistant/.opencode/agents/assistant.md', exists: true, created: true },
+    })
+    const onNavigate = vi.fn()
+    const { result } = renderHook(() => useAssistantSessionLauncher({
+      repoId: 123,
+      opcodeUrl: 'http://localhost:5551',
+      onNavigate,
+    }))
+
+    await act(async () => {
+      await expect(result.current.openAssistant()).rejects.toThrow('Assistant workspace is not ready')
+    })
+
+    expect(OpenCodeClient).not.toHaveBeenCalled()
+    expect(mocks.listSessionsPage).not.toHaveBeenCalled()
+    expect(mocks.createSession).not.toHaveBeenCalled()
+    expect(onNavigate).not.toHaveBeenCalled()
+  })
+
+  it('rejects with readiness error when opencodeJson is missing', async () => {
+    mocks.getAssistantModeStatus.mockResolvedValue({
+      directory: '/assistant',
+      files: {
+        agentsMd: { path: '/assistant/AGENTS.md', exists: true, created: true },
+        opencodeJson: { path: '/assistant/.opencode.json', exists: false, created: false },
+      },
+      defaultAgent: { name: 'assistant', path: '/assistant/.opencode/agents/assistant.md', exists: true, created: true },
+    })
+    const onNavigate = vi.fn()
+    const { result } = renderHook(() => useAssistantSessionLauncher({
+      repoId: 123,
+      opcodeUrl: 'http://localhost:5551',
+      onNavigate,
+    }))
+
+    await act(async () => {
+      await expect(result.current.openAssistant()).rejects.toThrow('Assistant workspace is not ready')
+    })
+
+    expect(OpenCodeClient).not.toHaveBeenCalled()
+    expect(mocks.listSessionsPage).not.toHaveBeenCalled()
+    expect(mocks.createSession).not.toHaveBeenCalled()
+    expect(onNavigate).not.toHaveBeenCalled()
+  })
+
+  it('rejects with readiness error when defaultAgent is missing', async () => {
+    mocks.getAssistantModeStatus.mockResolvedValue({
+      directory: '/assistant',
+      files: {
+        agentsMd: { path: '/assistant/AGENTS.md', exists: true, created: true },
+        opencodeJson: { path: '/assistant/.opencode.json', exists: true, created: true },
+      },
+      defaultAgent: undefined,
+    })
+    const onNavigate = vi.fn()
+    const { result } = renderHook(() => useAssistantSessionLauncher({
+      repoId: 123,
+      opcodeUrl: 'http://localhost:5551',
+      onNavigate,
+    }))
+
+    await act(async () => {
+      await expect(result.current.openAssistant()).rejects.toThrow('Assistant workspace is not ready')
+    })
+
+    expect(OpenCodeClient).not.toHaveBeenCalled()
+    expect(mocks.listSessionsPage).not.toHaveBeenCalled()
+    expect(mocks.createSession).not.toHaveBeenCalled()
+    expect(onNavigate).not.toHaveBeenCalled()
+  })
 })
diff --git a/frontend/src/hooks/useAssistantSessionLauncher.ts b/frontend/src/hooks/useAssistantSessionLauncher.ts
@@ -1,5 +1,5 @@
 import { useCallback } from 'react'
-import { initializeAssistantMode } from '@/api/repos'
+import { getAssistantModeStatus } from '@/api/repos'
 import { OpenCodeClient } from '@/api/opencode'
 import type { AssistantModeStatus } from '@opencode-manager/shared/types'
 import type { components } from '@/api/opencode-types'
@@ -113,13 +113,21 @@ async function sendAssistantModeWarningsPrompt(client: OpenCodeClient, sessionId
   }).catch(() => undefined)
 }
 
+function assertAssistantReady(assistant: AssistantModeStatus): void {
+  if (!assistant.files.agentsMd.exists || !assistant.files.opencodeJson.exists || !assistant.defaultAgent?.exists) {
+    throw new Error('Assistant workspace is not ready. Restart the server to run Assistant setup.')
+  }
+}
+
 export function useAssistantSessionLauncher({
   repoId,
   opcodeUrl,
   onNavigate,
 }: UseAssistantSessionLauncherOptions) {
   const openAssistant = useCallback(async () => {
-    const assistant = await initializeAssistantMode(repoId)
+    const assistant = await getAssistantModeStatus(repoId)
+    assertAssistantReady(assistant)
+
     const client = new OpenCodeClient(opcodeUrl, assistant.directory)
     const assistantDirectory = assistant.directory
 
diff --git a/frontend/src/pages/AssistantRedirect.tsx b/frontend/src/pages/AssistantRedirect.tsx
@@ -1,7 +1,7 @@
 import { useCallback, useEffect, useState } from "react"
 import { useParams, useNavigate, useLocation } from "react-router-dom"
 import { useQuery, useQueryClient } from "@tanstack/react-query"
-import { getRepo, initializeAssistantMode } from "@/api/repos"
+import { getRepo, getAssistantModeStatus } from "@/api/repos"
 import { useAssistantSessionLauncher } from "@/hooks/useAssistantSessionLauncher"
 import { useCreateSession } from "@/hooks/useOpenCode"
 import { useDialogParam } from "@/hooks/useDialogParam"
@@ -60,7 +60,7 @@ export function AssistantRedirect() {
 
   const { data: assistantMode, isLoading: assistantModeLoading, error: assistantModeError } = useQuery({
     queryKey: ["repo", repoId, "assistant-mode"],
-    queryFn: () => initializeAssistantMode(repoId),
+    queryFn: () => getAssistantModeStatus(repoId),
     enabled: showSessionList && repoId !== undefined,
   })
 
@@ -204,7 +204,7 @@ export function AssistantRedirect() {
           <>
             <Loader2 className="w-8 h-8 animate-spin text-muted-foreground mx-auto mb-4" />
             <p className="text-muted-foreground">
-              {status === "preparing" && "Preparing Assistant workspace..."}
+              {status === "preparing" && "Opening Assistant..."}
               {status === "creating" && "Opening your last session chat..."}
               {status === "opening" && "Opening your last session chat..."}
             </p>
diff --git a/frontend/src/pages/SessionDetail.tsx b/frontend/src/pages/SessionDetail.tsx
diff --git a/frontend/src/pages/__tests__/SessionDetail.assistant-loading.test.tsx b/frontend/src/pages/__tests__/SessionDetail.assistant-loading.test.tsx
