fix(opencode): avoid redundant resolution and url leaks

simstudioai · Danigm-dev · Mar 25, 2026 · Mar 25, 2026 · Mar 25, 2026 · Mar 25, 2026
commit 1e174f75a9e04344b21ad5ed42deb114f6e4e465
diff --git a/apps/sim/app/api/tools/opencode/prompt/route.test.ts b/apps/sim/app/api/tools/opencode/prompt/route.test.ts
@@ -142,9 +142,19 @@ describe('POST /api/tools/opencode/prompt', () => {
     expect(mockBuildOpenCodeSessionMemoryKey).toHaveBeenCalledWith('wf-1', 'user:user-123')
     expect(mockGetStoredOpenCodeSession).toHaveBeenCalledWith('ws-1', 'memory-key')
     expect(mockBuildOpenCodeSessionTitle).toHaveBeenCalledWith('repo-a', 'user:user-123')
-    expect(mockCreateOpenCodeSession).toHaveBeenCalledWith('repo-a', 'session-title')
+    expect(mockCreateOpenCodeSession).toHaveBeenCalledWith(
+      expect.objectContaining({
+        id: 'repo-a',
+        directory: '/app/repos/repo-a',
+      }),
+      'session-title'
+    )
     expect(mockPromptOpenCodeSession).toHaveBeenCalledWith({
       repository: 'repo-a',
+      repositoryOption: expect.objectContaining({
+        id: 'repo-a',
+        directory: '/app/repos/repo-a',
+      }),
       sessionId: 'session-1',
       prompt: 'explain the change',
       systemPrompt: 'system prompt',
@@ -202,6 +212,10 @@ describe('POST /api/tools/opencode/prompt', () => {
     expect(mockCreateOpenCodeSession).not.toHaveBeenCalled()
     expect(mockPromptOpenCodeSession).toHaveBeenCalledWith({
       repository: 'repo-a',
+      repositoryOption: expect.objectContaining({
+        id: 'repo-a',
+        directory: '/app/repos/repo-a',
+      }),
       sessionId: 'stored-session',
       prompt: 'continue',
       systemPrompt: undefined,
@@ -254,7 +268,13 @@ describe('POST /api/tools/opencode/prompt', () => {
     expect(mockShouldRetryWithFreshOpenCodeSession).toHaveBeenCalledWith(
       expect.objectContaining({ message: 'session not found' })
     )
-    expect(mockCreateOpenCodeSession).toHaveBeenCalledWith('repo-a', 'session-title')
+    expect(mockCreateOpenCodeSession).toHaveBeenCalledWith(
+      expect.objectContaining({
+        id: 'repo-a',
+        directory: '/app/repos/repo-a',
+      }),
+      'session-title'
+    )
     expect(mockStoreOpenCodeSession).toHaveBeenCalledWith(
       'ws-1',
       'memory-key',

diff --git a/apps/sim/app/api/tools/opencode/prompt/route.ts b/apps/sim/app/api/tools/opencode/prompt/route.ts
@@ -99,13 +99,15 @@ function buildErrorResponse(
 async function executePrompt(
   params: z.infer<typeof OpenCodePromptSchema>,
   repository: string,
+  repositoryOption: Awaited<ReturnType<typeof resolveOpenCodeRepositoryOption>>,
   threadId: string,
   prompt: string,
   providerId: string,
   modelId: string
 ) {
   return promptOpenCodeSession({
     repository,
+    repositoryOption,
     sessionId: threadId,
     prompt,
     systemPrompt: params.systemPrompt?.trim() || undefined,
@@ -146,18 +148,28 @@ export async function POST(request: NextRequest) {
     const newThread = coerceBoolean(body.newThread)
     const storedThread = newThread ? null : await getStoredOpenCodeSession(workspaceId, memoryKey)
     let threadId =
-      storedThread && storedThread.repository === repositoryId ? storedThread.sessionId : undefined
+      storedThread && storedThread.repository === repositoryId
+        ? storedThread.sessionId
+        : undefined
 
     if (!threadId) {
       const session = await createOpenCodeSession(
-        repositoryId,
+        repositoryOption,
         buildOpenCodeSessionTitle(repositoryId, sessionOwnerKey)
       )
       threadId = session.id
     }
 
     try {
-      const result = await executePrompt(body, repositoryId, threadId, prompt, providerId, modelId)
+      const result = await executePrompt(
+        body,
+        repositoryId,
+        repositoryOption,
+        threadId,
+        prompt,
+        providerId,
+        modelId
+      )
 
       await storeOpenCodeSession(workspaceId, memoryKey, {
         sessionId: result.threadId,
@@ -179,12 +191,13 @@ export async function POST(request: NextRequest) {
       if (threadId && !newThread && shouldRetryWithFreshOpenCodeSession(error)) {
         try {
           const freshSession = await createOpenCodeSession(
-            repositoryId,
+            repositoryOption,
             buildOpenCodeSessionTitle(repositoryId, sessionOwnerKey)
           )
           const result = await executePrompt(
             body,
             repositoryId,
+            repositoryOption,
             freshSession.id,
             prompt,
             providerId,
@@ -214,13 +227,16 @@ export async function POST(request: NextRequest) {
           )
 
           const errorMessage =
-            retryError instanceof Error ? retryError.message : 'OpenCode prompt retry failed'
+            retryError instanceof Error
+              ? retryError.message
+              : 'OpenCode prompt retry failed'
           return buildErrorResponse(threadId, '', undefined, errorMessage)
         }
       }
 
       await logOpenCodeFailure('Failed to execute OpenCode prompt', error)
-      const errorMessage = error instanceof Error ? error.message : 'OpenCode prompt failed'
+      const errorMessage =
+        error instanceof Error ? error.message : 'OpenCode prompt failed'
       return buildErrorResponse(threadId || '', '', undefined, errorMessage)
     }
   } catch (error) {

diff --git a/apps/sim/lib/opencode/errors.test.ts b/apps/sim/lib/opencode/errors.test.ts
@@ -0,0 +1,22 @@
+/**
+ * @vitest-environment node
+ */
+
+import { describe, expect, it } from 'vitest'
+import { getOpenCodeRouteError } from '@/lib/opencode/errors'
+
+describe('getOpenCodeRouteError', () => {
+  it('does not leak the internal OpenCode base URL in connectivity errors', () => {
+    const error = getOpenCodeRouteError(
+      new Error('fetch failed for http://opencode:4096/session'),
+      'repositories',
+    )
+
+    expect(error).toEqual({
+      status: 503,
+      message:
+        'OpenCode server is unreachable. Check OPENCODE_BASE_URL and the runtime network configuration.',
+    })
+    expect(error.message).not.toContain('http://opencode:4096')
+  })
+})
diff --git a/apps/sim/lib/opencode/errors.ts b/apps/sim/lib/opencode/errors.ts
@@ -1,5 +1,3 @@
-import { getOpenCodeBaseUrl } from '@/lib/opencode/client'
-
 export interface OpenCodeRouteError {
   status: number
   message: string
@@ -72,7 +70,8 @@ export function getOpenCodeRouteError(error: unknown, resourceName: string): Ope
   ) {
     return {
       status: 503,
-      message: `OpenCode server is unreachable at ${getOpenCodeBaseUrl()}.`,
+      message:
+        'OpenCode server is unreachable. Check OPENCODE_BASE_URL and the runtime network configuration.',
     }
   }
 

diff --git a/apps/sim/lib/opencode/service.test.ts b/apps/sim/lib/opencode/service.test.ts
@@ -4,6 +4,10 @@
 
 import { describe, expect, it, vi } from 'vitest'
 
+const { mockCreateOpenCodeClient } = vi.hoisted(() => ({
+  mockCreateOpenCodeClient: vi.fn(),
+}))
+
 vi.mock('@sim/db', () => ({
   db: {},
 }))
@@ -31,10 +35,13 @@ vi.mock('drizzle-orm', () => ({
 }))
 
 vi.mock('@/lib/opencode/client', () => ({
-  createOpenCodeClient: vi.fn(),
+  createOpenCodeClient: mockCreateOpenCodeClient,
 }))
 
-import { shouldRetryWithFreshOpenCodeSession } from '@/lib/opencode/service'
+import {
+  promptOpenCodeSession,
+  shouldRetryWithFreshOpenCodeSession,
+} from '@/lib/opencode/service'
 
 describe('shouldRetryWithFreshOpenCodeSession', () => {
   it('returns true for stale-session errors', () => {
@@ -50,3 +57,72 @@ describe('shouldRetryWithFreshOpenCodeSession', () => {
     expect(shouldRetryWithFreshOpenCodeSession('provider does not exist')).toBe(false)
   })
 })
+
+describe('promptOpenCodeSession', () => {
+  it('reuses the provided repository option without resolving repositories again', async () => {
+    const mockSessionCreate = vi.fn().mockResolvedValue({
+      data: { id: 'session-1' },
+    })
+    const mockSessionPrompt = vi.fn().mockResolvedValue({
+      data: {
+        info: {
+          sessionID: 'session-1',
+          cost: 0.75,
+          providerID: 'provider-a',
+          modelID: 'model-a',
+        },
+        parts: [{ type: 'text', text: 'OpenCode result' }],
+      },
+    })
+
+    mockCreateOpenCodeClient.mockReturnValue({
+      project: {
+        list: vi.fn(),
+      },
+      session: {
+        create: mockSessionCreate,
+        prompt: mockSessionPrompt,
+      },
+    })
+
+    const result = await promptOpenCodeSession({
+      repository: 'repo-a',
+      repositoryOption: {
+        id: 'repo-a',
+        label: 'repo-a',
+        directory: '/app/repos/repo-a',
+        projectId: 'project-1',
+      },
+      prompt: 'Explain the change',
+      providerId: 'provider-a',
+      modelId: 'model-a',
+      title: 'session-title',
+    })
+
+    expect(mockSessionCreate).toHaveBeenCalledWith({
+      query: { directory: '/app/repos/repo-a' },
+      body: { title: 'session-title' },
+      throwOnError: true,
+    })
+    expect(mockSessionPrompt).toHaveBeenCalledWith({
+      path: { id: 'session-1' },
+      query: { directory: '/app/repos/repo-a' },
+      body: {
+        parts: [{ type: 'text', text: 'Explain the change' }],
+        model: {
+          providerID: 'provider-a',
+          modelID: 'model-a',
+        },
+      },
+      throwOnError: true,
+    })
+    expect(result).toEqual({
+      content: 'OpenCode result',
+      threadId: 'session-1',
+      cost: 0.75,
+      providerId: 'provider-a',
+      modelId: 'model-a',
+      assistantError: undefined,
+    })
+  })
+})
diff --git a/apps/sim/lib/opencode/service.ts b/apps/sim/lib/opencode/service.ts
@@ -52,6 +52,7 @@ export interface OpenCodePromptRequest {
   prompt: string
   providerId: string
   modelId: string
+  repositoryOption?: OpenCodeRepositoryOption
   systemPrompt?: string
   agent?: string
   sessionId?: string
@@ -295,6 +296,16 @@ export async function resolveOpenCodeRepositoryOption(
   return repositoryOption
 }
 
+async function getOpenCodeRepositoryOption(
+  repository: string | OpenCodeRepositoryOption
+): Promise<OpenCodeRepositoryOption> {
+  if (typeof repository === 'string') {
+    return resolveOpenCodeRepositoryOption(repository)
+  }
+
+  return repository
+}
+
 export async function listOpenCodeProviders(
   repository?: string
 ): Promise<OpenCodeProviderOption[]> {
@@ -352,11 +363,11 @@ export async function listOpenCodeAgents(repository?: string): Promise<OpenCodeA
 }
 
 export async function createOpenCodeSession(
-  repository: string,
+  repository: string | OpenCodeRepositoryOption,
   title?: string
 ): Promise<{ id: string }> {
   const client = createOpenCodeClient()
-  const repositoryOption = await resolveOpenCodeRepositoryOption(repository)
+  const repositoryOption = await getOpenCodeRepositoryOption(repository)
   const sessionResult = await client.session.create({
     query: { directory: repositoryOption.directory },
     body: title ? { title } : undefined,
@@ -370,10 +381,13 @@ export async function promptOpenCodeSession(
   request: OpenCodePromptRequest
 ): Promise<OpenCodePromptResult> {
   const client = createOpenCodeClient()
-  const repositoryOption = await resolveOpenCodeRepositoryOption(request.repository)
+  const repositoryOption =
+    request.repositoryOption ||
+    (await resolveOpenCodeRepositoryOption(request.repository))
   const directory = repositoryOption.directory
   const sessionId =
-    request.sessionId || (await createOpenCodeSession(request.repository, request.title)).id
+    request.sessionId ||
+    (await createOpenCodeSession(repositoryOption, request.title)).id
 
   const response = await client.session.prompt({
     path: { id: sessionId },
@@ -433,7 +447,13 @@ export async function getStoredOpenCodeSession(
   const result = await db
     .select({ data: memory.data })
     .from(memory)
-    .where(and(eq(memory.workspaceId, workspaceId), eq(memory.key, key), isNull(memory.deletedAt)))
+    .where(
+      and(
+        eq(memory.workspaceId, workspaceId),
+        eq(memory.key, key),
+        isNull(memory.deletedAt)
+      )
+    )
     .limit(1)
 
   if (result.length === 0) {
@@ -520,6 +540,9 @@ export function shouldRetryWithFreshOpenCodeSession(error: unknown): boolean {
   return normalized.includes('404') && normalized.includes('session')
 }
 
-export async function logOpenCodeFailure(message: string, error: unknown): Promise<void> {
+export async function logOpenCodeFailure(
+  message: string,
+  error: unknown
+): Promise<void> {
   logger.error(message, { error })
 }