@cloudcli-ai/cloudcli 1.36.3 → 1.37.1

package/server/{opencode-cli.js → modules/providers/list/opencode/opencode-runtime.provider.js}

@@ -3,12 +3,13 @@ import fsSync from 'node:fs';
 import crossSpawn from 'cross-spawn';
 import Database from 'better-sqlite3';
 
-import { appendImagesInputTag } from './shared/image-attachments.js';
-import { sessionsService } from './modules/providers/services/sessions.service.js';
-import { providerAuthService } from './modules/providers/services/provider-auth.service.js';
-import { providerModelsService } from './modules/providers/services/provider-models.service.js';
-import { notifyRunFailed, notifyRunStopped } from './services/notification-orchestrator.js';
-import { createCompleteMessage, createNormalizedMessage, flattenPromptForWindowsShell, getOpenCodeDatabasePath } from './shared/utils.js';
+import {
+  appendFilesInputTag,
+  appendImagesInputTag,
+  normalizeAttachmentDescriptors
+} from '@/shared/image-attachments.js';
+import { notifyRunFailed, notifyRunStopped } from '@/modules/notifications/index.js';
+import { createCompleteMessage, createNormalizedMessage, flattenPromptForWindowsShell, getOpenCodeDatabasePath } from '@/shared/utils.js';
 
 // cross-spawn resolves .cmd shims/PATHEXT on Windows and delegates to
 // child_process.spawn everywhere else.
@@ -122,12 +123,27 @@ function readOpenCodeTokenUsage(sessionId) {
   }
 }
 
-async function spawnOpenCode(command, options = {}, ws) {
+async function spawnOpenCode(command, options = {}, ws, context) {
   return new Promise((resolve, reject) => {
-    const { sessionId, projectPath, cwd, model, effort, sessionSummary, images, permissionMode } = options;
+    const {
+      sessionId,
+      projectPath,
+      cwd,
+      model,
+      effort,
+      sessionSummary,
+      images,
+      files,
+      permissionMode
+    } = options;
+    // Callers pass the stable app session id; the CLI resumes with the
+    // provider-native id recorded on the session row.
+    const providerSessionId = context.resolveProviderSessionId(sessionId);
     const workingDir = cwd || projectPath || process.cwd();
+    // Process-map key: the app session id when the caller supplied one, so
+    // abort-by-app-id always works.
     const processKey = sessionId || Date.now().toString();
-    let capturedSessionId = sessionId || null;
+    let capturedSessionId = providerSessionId;
     let sessionCreatedSent = false;
     let stdoutLineBuffer = '';
     let terminalNotificationSent = false;
@@ -142,7 +158,8 @@ async function spawnOpenCode(command, options = {}, ws) {
       }
 
       terminalNotificationSent = true;
-      const finalSessionId = capturedSessionId || sessionId || processKey;
+      // Notifications are app-facing, so they carry the app session id.
+      const finalSessionId = sessionId || capturedSessionId || processKey;
       if (code === 0 && !error) {
         notifyRunStopped({
           userId: ws?.userId || null,
@@ -169,7 +186,9 @@ async function spawnOpenCode(command, options = {}, ws) {
       }
 
       capturedSessionId = nextSessionId;
-      if (processKey !== capturedSessionId && opencodeProcess) {
+      // Legacy/direct callers without an app session id re-key the process
+      // under the provider-native id once it is known.
+      if (!sessionId && processKey !== capturedSessionId && opencodeProcess) {
         activeOpenCodeProcesses.delete(processKey);
         activeOpenCodeProcesses.set(capturedSessionId, opencodeProcess);
       }
@@ -181,7 +200,7 @@ async function spawnOpenCode(command, options = {}, ws) {
         ws.setSessionId(capturedSessionId);
       }
 
-      if (!sessionId && !sessionCreatedSent) {
+      if (!providerSessionId && !sessionCreatedSent) {
         sessionCreatedSent = true;
         ws.send(createNormalizedMessage({
           kind: 'session_created',
@@ -212,11 +231,7 @@ async function spawnOpenCode(command, options = {}, ws) {
 
       try {
         registerSession(readOpenCodeSessionId(response));
-        const normalized = sessionsService.normalizeMessage(
-          'opencode',
-          response,
-          capturedSessionId || sessionId || null,
-        );
+        const normalized = context.normalizeMessage(response, capturedSessionId || sessionId || null);
         for (const msg of normalized) {
           ws.send(msg);
         }
@@ -232,10 +247,10 @@ async function spawnOpenCode(command, options = {}, ws) {
       }
     };
 
-    void providerModelsService.resolveResumeModel('opencode', sessionId, model).then(async (resolvedModel) => {
+    void context.resolveResumeModel(sessionId, model).then(async (resolvedModel) => {
       let effortModels = null;
       try {
-        effortModels = (await providerModelsService.getProviderModels('opencode')).models;
+        effortModels = await context.getProviderModels();
       } catch (error) {
         console.warn('[OpenCode] Unable to load provider models for effort validation:', error);
       }
@@ -246,8 +261,8 @@ async function spawnOpenCode(command, options = {}, ws) {
       // Relying on the child-process cwd alone is not enough on Linux, where
       // the CLI can still resolve the session under the server install dir.
       args.push('--dir', workingDir);
-      if (sessionId) {
-        args.push('--session', sessionId);
+      if (providerSessionId) {
+        args.push('--session', providerSessionId);
       }
       if (resolvedModel) {
         args.push('--model', resolvedModel);
@@ -257,12 +272,19 @@ async function spawnOpenCode(command, options = {}, ws) {
       }
       const permissionOptions = resolveOpenCodePermissionOptions(permissionMode);
       args.push(...permissionOptions.args);
-      if (command && command.trim()) {
+      const hasAttachments =
+        normalizeAttachmentDescriptors(images).length > 0
+        || normalizeAttachmentDescriptors(files).length > 0;
+      if ((command && command.trim()) || hasAttachments) {
         // Image attachments ride along as an <images_input> path list appended
         // to the prompt; the session history reader strips the tag back out.
         // opencode is a .cmd shim on Windows, so the whole argument must be
         // newline-free or cmd.exe silently truncates it at the first newline.
-        args.push(flattenPromptForWindowsShell(appendImagesInputTag(command.trim(), images)));
+        const promptWithAttachments = appendFilesInputTag(
+          appendImagesInputTag(command?.trim() || '', images),
+          files
+        );
+        args.push(flattenPromptForWindowsShell(promptWithAttachments));
       }
 
       opencodeProcess = spawnFunction('opencode', args, {
@@ -300,7 +322,7 @@ async function spawnOpenCode(command, options = {}, ws) {
       });
 
       opencodeProcess.on('close', async (code) => {
-        const finalSessionId = capturedSessionId || sessionId || processKey;
+        const finalSessionId = sessionId || capturedSessionId || processKey;
         activeOpenCodeProcesses.delete(finalSessionId);
         activeOpenCodeProcesses.delete(processKey);
 
@@ -309,7 +331,8 @@ async function spawnOpenCode(command, options = {}, ws) {
           stdoutLineBuffer = '';
         }
 
-        const tokenBudget = readOpenCodeTokenUsage(finalSessionId);
+        // OpenCode's own database is keyed by the provider-native id.
+        const tokenBudget = readOpenCodeTokenUsage(capturedSessionId);
         if (tokenBudget) {
           ws.send(createNormalizedMessage({
             kind: 'status',
@@ -334,7 +357,7 @@ async function spawnOpenCode(command, options = {}, ws) {
         }
 
         if (code === 127 || code === null) {
-          const installed = await providerAuthService.isProviderInstalled('opencode');
+          const installed = await context.isProviderInstalled();
           if (!installed) {
             ws.send(createNormalizedMessage({
               kind: 'error',
@@ -350,11 +373,11 @@ async function spawnOpenCode(command, options = {}, ws) {
       });
 
       opencodeProcess.on('error', async (error) => {
-        const finalSessionId = capturedSessionId || sessionId || processKey;
+        const finalSessionId = sessionId || capturedSessionId || processKey;
         activeOpenCodeProcesses.delete(finalSessionId);
         activeOpenCodeProcesses.delete(processKey);
 
-        const installed = await providerAuthService.isProviderInstalled('opencode');
+        const installed = await context.isProviderInstalled();
         const errorContent = !installed
           ? 'OpenCode CLI is not installed. Install it from https://opencode.ai/docs/'
           : error.message;
@@ -398,6 +421,11 @@ function getActiveOpenCodeSessions() {
   return Array.from(activeOpenCodeProcesses.keys());
 }
 
+export const opencodeRuntime = {
+  run: spawnOpenCode,
+  abort: abortOpenCodeSession,
+};
+
 export {
   spawnOpenCode,
   abortOpenCodeSession,

package/server/{opencode-cli.test.js → modules/providers/list/opencode/opencode-runtime.provider.test.js}

@@ -4,7 +4,20 @@ import os from 'node:os';
 import path from 'node:path';
 import test from 'node:test';
 
-import { resolveOpenCodePermissionOptions, spawnOpenCode } from './opencode-cli.js';
+import {
+  opencodeRuntime,
+  resolveOpenCodePermissionOptions,
+} from './opencode-runtime.provider.js';
+import { OpenCodeSessionsProvider } from './opencode-sessions.provider.js';
+
+const sessionsProvider = new OpenCodeSessionsProvider();
+const runtimeContext = {
+  resolveProviderSessionId: (sessionId) => sessionId || null,
+  resolveResumeModel: async (_sessionId, requestedModel) => requestedModel || undefined,
+  getProviderModels: async () => ({ OPTIONS: [], DEFAULT: '' }),
+  normalizeMessage: (raw, sessionId) => sessionsProvider.normalizeMessage(raw, sessionId),
+  isProviderInstalled: async () => true,
+};
 
 const findEnvKey = (name) =>
   Object.keys(process.env).find((key) => key.toLowerCase() === name.toLowerCase()) || name;
@@ -71,7 +84,7 @@ test('spawnOpenCode emits session_created before normalized live messages for ne
         : `.COM;.EXE;.BAT;.CMD${previousPathExt ? `;${previousPathExt}` : ''}`;
     }
 
-    await spawnOpenCode('Hi', { cwd: tempRoot }, writer);
+    await opencodeRuntime.run('Hi', { cwd: tempRoot }, writer, runtimeContext);
 
     const sessionCreatedIndex = messages.findIndex((message) => message.kind === 'session_created');
     const assistantDeltaIndex = messages.findIndex((message) =>
@@ -98,6 +111,26 @@ test('spawnOpenCode emits session_created before normalized live messages for ne
     assert.equal(launchedArgs.includes('--auto'), false);
     assert.equal(launchedArgs.includes('--agent'), false);
     assert.equal(capture.permissionEnv, null);
+
+    const attachmentOnlyCapturePath = path.join(tempRoot, 'opencode-attachment-only.json');
+    process.env.OPENCODE_ARGS_CAPTURE = attachmentOnlyCapturePath;
+    await opencodeRuntime.run(
+      '',
+      {
+        cwd: tempRoot,
+        files: [{
+          path: path.join(tempRoot, 'brief.pdf'),
+          name: 'brief.pdf',
+          mimeType: 'application/pdf',
+        }],
+      },
+      writer,
+      runtimeContext,
+    );
+    const attachmentOnlyCapture = JSON.parse(await readFile(attachmentOnlyCapturePath, 'utf8'));
+    const attachmentPrompt = attachmentOnlyCapture.args[attachmentOnlyCapture.args.length - 1];
+    assert.match(attachmentPrompt, /<files_input>/);
+    assert.match(attachmentPrompt, /brief\.pdf/);
   } finally {
     if (previousPath === undefined) {
       delete process.env[pathKey];
@@ -186,7 +219,12 @@ test('spawnOpenCode passes permission mode flags and env to the CLI', async () =
       const argsCapturePath = path.join(tempRoot, `opencode-args-${scenario.permissionMode}.json`);
       process.env.OPENCODE_ARGS_CAPTURE = argsCapturePath;
 
-      await spawnOpenCode('Hi', { cwd: tempRoot, permissionMode: scenario.permissionMode }, writer);
+      await opencodeRuntime.run(
+        'Hi',
+        { cwd: tempRoot, permissionMode: scenario.permissionMode },
+        writer,
+        runtimeContext,
+      );
 
       const capture = JSON.parse(await readFile(argsCapturePath, 'utf8'));
       for (const expectedArg of scenario.expectArgs) {

package/server/modules/providers/list/opencode/opencode-session-synchronizer.provider.ts

@@ -130,22 +130,9 @@ export class OpenCodeSessionSynchronizer implements IProviderSessionSynchronizer
       ?? sessionsDb.getSessionById(sessionId);
     const existingName = existingSession?.custom_name;
 
-    // Sessions started by sending a message from cloudcli carry a distinct
-    // app-allocated session_id mapped to the provider id. For these we title the
-    // conversation from the first user message the user typed, matching how the
-    // app titles a brand-new conversation. Sessions discovered purely by
-    // indexing (session_id === provider_session_id) keep OpenCode's own stored
-    // title.
-    const isAppCreated =
-      existingSession != null &&
-      existingSession.provider_session_id != null &&
-      existingSession.session_id !== existingSession.provider_session_id;
-
     let nextName: string | undefined;
     if (existingName && existingName !== fallbackTitle) {
       nextName = existingName;
-    } else if (isAppCreated) {
-      nextName = this.readFirstUserText(db, sessionId) ?? readOptionalString(row.title);
     } else {
       nextName = readOptionalString(row.title) ?? this.readFirstUserText(db, sessionId);
     }

package/server/modules/providers/list/opencode/opencode-sessions.provider.ts

@@ -2,7 +2,7 @@ import fsSync from 'node:fs';
 
 import Database from 'better-sqlite3';
 
-import { parseImagesInputTag } from '@/shared/image-attachments.js';
+import { parseFilesInputTag, parseImagesInputTag } from '@/shared/image-attachments.js';
 import type { IProviderSessions } from '@/shared/interfaces.js';
 import type { AnyRecord, FetchHistoryOptions, FetchHistoryResult, NormalizedMessage } from '@/shared/types.js';
 import {
@@ -404,10 +404,17 @@ export class OpenCodeSessionsProvider implements IProviderSessions {
         const rawContent = extractText(partData);
         // User prompts sent with attachments carry an <images_input> path
         // list; strip it for display and surface the paths as images.
-        const { text: content, attachments } = messageRole === 'user'
+        const parsedImages = messageRole === 'user'
           ? parseImagesInputTag(rawContent)
           : { text: rawContent, attachments: [] };
-        if (content.trim() || attachments.length > 0) {
+        const parsedFiles = messageRole === 'user'
+          ? parseFilesInputTag(parsedImages.text)
+          : { text: rawContent, attachments: [] };
+        if (
+          parsedFiles.text.trim()
+          || parsedImages.attachments.length > 0
+          || parsedFiles.attachments.length > 0
+        ) {
           normalized.push(createNormalizedMessage({
             id: baseId,
             sessionId,
@@ -415,8 +422,9 @@ export class OpenCodeSessionsProvider implements IProviderSessions {
             provider: PROVIDER,
             kind: 'text',
             role: messageRole === 'user' ? 'user' : 'assistant',
-            content,
-            images: attachments.length > 0 ? attachments : undefined,
+            content: parsedFiles.text,
+            images: parsedImages.attachments.length > 0 ? parsedImages.attachments : undefined,
+            files: parsedFiles.attachments.length > 0 ? parsedFiles.attachments : undefined,
           }));
         }
         continue;

package/server/modules/providers/list/opencode/opencode.provider.ts

@@ -1,5 +1,6 @@
 import { OpenCodeProviderAuth } from '@/modules/providers/list/opencode/opencode-auth.provider.js';
 import { OpenCodeProviderModels } from '@/modules/providers/list/opencode/opencode-models.provider.js';
+import { opencodeRuntime } from '@/modules/providers/list/opencode/opencode-runtime.provider.js';
 import { OpenCodeMcpProvider } from '@/modules/providers/list/opencode/opencode-mcp.provider.js';
 import { OpenCodeSessionSynchronizer } from '@/modules/providers/list/opencode/opencode-session-synchronizer.provider.js';
 import { OpenCodeSessionsProvider } from '@/modules/providers/list/opencode/opencode-sessions.provider.js';
@@ -8,12 +9,14 @@ import { AbstractProvider } from '@/modules/providers/shared/base/abstract.provi
 import type {
   IProviderAuth,
   IProviderModels,
+  IProviderRuntime,
   IProviderSessionSynchronizer,
   IProviderSkills,
   IProviderSessions,
 } from '@/shared/interfaces.js';
 
 export class OpenCodeProvider extends AbstractProvider {
+  readonly runtime: IProviderRuntime = opencodeRuntime;
   readonly models: IProviderModels = new OpenCodeProviderModels();
   readonly mcp = new OpenCodeMcpProvider();
   readonly auth: IProviderAuth = new OpenCodeProviderAuth();