@glwhappen/web-code 1.32.7 → 1.32.10

package/server/modules/providers/tests/skills.test.ts

@@ -377,6 +377,72 @@ test('providerSkillsService lists codex repository, user, and system skills', {
   }
 });
 
+/**
+ * This test covers OpenCode skill lookup across cwd-to-git-root project folders
+ * plus the global OpenCode/Claude/Agents compatibility locations.
+ */
+test('providerSkillsService lists opencode project and user compatibility skills', { concurrency: false }, async () => {
+  const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'llm-skills-opencode-'));
+  const repoRoot = path.join(tempRoot, 'repo');
+  const workspacePath = path.join(repoRoot, 'packages', 'app');
+  await fs.mkdir(path.join(repoRoot, '.git'), { recursive: true });
+  await fs.mkdir(workspacePath, { recursive: true });
+
+  const restoreHomeDir = patchHomeDir(tempRoot);
+  try {
+    await writeSkill(
+      path.join(workspacePath, '.opencode', 'skills'),
+      'opencode-cwd-dir',
+      'opencode-cwd',
+      'OpenCode cwd skill',
+    );
+    await writeSkill(
+      path.join(repoRoot, 'packages', '.claude', 'skills'),
+      'opencode-claude-parent-dir',
+      'opencode-claude-parent',
+      'OpenCode Claude parent skill',
+    );
+    await writeSkill(
+      path.join(repoRoot, '.agents', 'skills'),
+      'opencode-agents-root-dir',
+      'opencode-agents-root',
+      'OpenCode Agents root skill',
+    );
+    await writeSkill(
+      path.join(tempRoot, '.config', 'opencode', 'skills'),
+      'opencode-user-dir',
+      'opencode-user',
+      'OpenCode user skill',
+    );
+    await writeSkill(
+      path.join(tempRoot, '.claude', 'skills'),
+      'opencode-claude-user-dir',
+      'opencode-claude-user',
+      'OpenCode Claude user skill',
+    );
+    await writeSkill(
+      path.join(tempRoot, '.agents', 'skills'),
+      'opencode-agents-user-dir',
+      'opencode-agents-user',
+      'OpenCode Agents user skill',
+    );
+
+    const skills = await providerSkillsService.listProviderSkills('opencode', { workspacePath });
+    const byName = new Map(skills.map((skill) => [skill.name, skill]));
+
+    assert.equal(byName.get('opencode-cwd')?.scope, 'project');
+    assert.equal(byName.get('opencode-claude-parent')?.scope, 'project');
+    assert.equal(byName.get('opencode-agents-root')?.scope, 'project');
+    assert.equal(byName.get('opencode-user')?.scope, 'user');
+    assert.equal(byName.get('opencode-claude-user')?.scope, 'user');
+    assert.equal(byName.get('opencode-agents-user')?.scope, 'user');
+    assert.equal(byName.get('opencode-cwd')?.command, '/opencode-cwd');
+  } finally {
+    restoreHomeDir();
+    await fs.rm(tempRoot, { recursive: true, force: true });
+  }
+});
+
 /**
  * This test covers Gemini and Cursor skill directory rules, including shared
  * `.agents/skills` project support.

package/server/modules/websocket/services/chat-websocket.service.ts

@@ -30,10 +30,12 @@ type ChatWebSocketDependencies = {
   spawnCursor: (command: string, options: unknown, writer: WebSocketWriter) => Promise<unknown>;
   queryCodex: (command: string, options: unknown, writer: WebSocketWriter) => Promise<unknown>;
   spawnGemini: (command: string, options: unknown, writer: WebSocketWriter) => Promise<unknown>;
+  spawnOpenCode: (command: string, options: unknown, writer: WebSocketWriter) => Promise<unknown>;
   abortClaudeSDKSession: (sessionId: string, userId?: string | number | null) => Promise<boolean>;
   abortCursorSession: (sessionId: string, userId?: string | number | null) => boolean;
   abortCodexSession: (sessionId: string, userId?: string | number | null) => boolean;
   abortGeminiSession: (sessionId: string, userId?: string | number | null) => boolean;
+  abortOpenCodeSession: (sessionId: string) => boolean;
   resolveToolApproval: (
     requestId: string,
     payload: {
@@ -47,19 +49,21 @@ type ChatWebSocketDependencies = {
   isCursorSessionActive: (sessionId: string, userId?: string | number | null) => boolean;
   isCodexSessionActive: (sessionId: string, userId?: string | number | null) => boolean;
   isGeminiSessionActive: (sessionId: string, userId?: string | number | null) => boolean;
+  isOpenCodeSessionActive: (sessionId: string) => boolean;
   reconnectSessionWriter: (sessionId: string, ws: WebSocket, userId?: string | number | null) => boolean;
   getPendingApprovalsForSession: (sessionId: string, userId?: string | number | null) => unknown[];
   getActiveClaudeSDKSessions: (userId?: string | number | null) => unknown;
   getActiveCursorSessions: (userId?: string | number | null) => unknown;
   getActiveCodexSessions: (userId?: string | number | null) => unknown;
   getActiveGeminiSessions: (userId?: string | number | null) => unknown;
+  getActiveOpenCodeSessions: () => unknown;
 };
 
 /**
  * Normalizes potentially invalid provider names coming from websocket payloads.
  */
 function readProvider(value: unknown): LLMProvider {
-  if (value === 'claude' || value === 'cursor' || value === 'codex' || value === 'gemini') {
+  if (value === 'claude' || value === 'cursor' || value === 'codex' || value === 'gemini' || value === 'opencode') {
     return value;
   }
 
@@ -199,6 +203,17 @@ export function handleChatConnection(
         return;
       }
 
+      if (messageType === 'opencode-command') {
+        const authorization = authorizeOptionsCwd(writer.userId, data.options);
+        if (!authorization.authorized) {
+          sendAuthorizationError(authorization.error, 'opencode');
+          return;
+        }
+        const sanitizedOptions = { ...(data.options ?? {}), cwd: authorization.cwd };
+        await dependencies.spawnOpenCode(data.command ?? '', sanitizedOptions, writer);
+        return;
+      }
+
       if (messageType === 'cursor-resume') {
         const authorization = authorizeOptionsCwd(writer.userId, data.options);
         if (!authorization.authorized) {
@@ -229,6 +244,8 @@ export function handleChatConnection(
           success = dependencies.abortCodexSession(sessionId, userId);
         } else if (provider === 'gemini') {
           success = dependencies.abortGeminiSession(sessionId, userId);
+        } else if (provider === 'opencode') {
+          success = dependencies.abortOpenCodeSession(sessionId);
         } else {
           success = await dependencies.abortClaudeSDKSession(sessionId, userId);
         }
@@ -286,6 +303,8 @@ export function handleChatConnection(
           isActive = dependencies.isCodexSessionActive(sessionId, userId);
         } else if (provider === 'gemini') {
           isActive = dependencies.isGeminiSessionActive(sessionId, userId);
+        } else if (provider === 'opencode') {
+          isActive = dependencies.isOpenCodeSessionActive(sessionId);
         } else {
           isActive = dependencies.isClaudeSDKSessionActive(sessionId, userId);
           if (isActive) {
@@ -325,6 +344,7 @@ export function handleChatConnection(
             cursor: dependencies.getActiveCursorSessions(userId),
             codex: dependencies.getActiveCodexSessions(userId),
             gemini: dependencies.getActiveGeminiSessions(userId),
+            opencode: dependencies.getActiveOpenCodeSessions(),
           },
         });
       }

package/server/modules/websocket/services/shell-websocket.service.ts

@@ -138,6 +138,13 @@ function buildShellCommand(
     return command;
   }
 
+  if (provider === 'opencode') {
+    if (hasSession && sessionId) {
+      return `opencode --session "${sessionId}"`;
+    }
+    return initialCommand || 'opencode';
+  }
+
   const command = initialCommand || 'claude';
   if (hasSession && sessionId) {
     if (os.platform() === 'win32') {
@@ -425,6 +432,8 @@ export function handleShellConnection(
                 ? 'Codex'
                 : provider === 'gemini'
                   ? 'Gemini'
+                  : provider === 'opencode'
+                    ? 'OpenCode'
                   : 'Claude';
           welcomeMsg = hasSession
             ? `\x1b[36mResuming ${providerName} session ${sessionId} in: ${projectPath}\x1b[0m\r\n`

package/server/modules/websocket/services/websocket-writer.service.ts

@@ -21,6 +21,13 @@ export class WebSocketWriter {
   send(data: unknown): void {
     if (this.ws.readyState === WS_OPEN_STATE) {
       this.ws.send(JSON.stringify(data));
+    } else {
+      const kind = (data as Record<string, unknown>)?.kind;
+      if (kind === 'complete' || kind === 'error') {
+        console.warn(
+          `[WebSocketWriter] Dropped "${kind}" event — socket not open (readyState=${this.ws.readyState}, session=${this.sessionId})`,
+        );
+      }
     }
   }
 

package/server/openai-codex.js

@@ -17,6 +17,7 @@ import { Codex } from '@openai/codex-sdk';
 import { notifyRunFailed, notifyRunStopped } from './services/notification-orchestrator.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 { createNormalizedMessage } from './shared/utils.js';
 
 // Track active sessions – keys are namespaced as `${userId}:${sessionId}`
@@ -27,6 +28,34 @@ function buildCodexSessionKey(userId, sessionId) {
   return `${safeUser}:${sessionId}`;
 }
 
+function readUsageNumber(value) {
+  const parsed = Number(value);
+  return Number.isFinite(parsed) ? parsed : 0;
+}
+
+function extractCodexTokenBudget(event) {
+  const info = event?.info || event?.payload?.info || event?.usage?.info;
+  const usage = info?.total_token_usage || event?.usage?.total_token_usage || event?.usage;
+  if (!usage || typeof usage !== 'object') {
+    return null;
+  }
+
+  const inputTokens = readUsageNumber(usage.input_tokens);
+  const outputTokens = readUsageNumber(usage.output_tokens);
+  const used = readUsageNumber(usage.total_tokens) || inputTokens + outputTokens;
+
+  return {
+    used,
+    total: readUsageNumber(info?.model_context_window || event?.usage?.model_context_window) || 200000,
+    inputTokens,
+    outputTokens,
+    breakdown: {
+      input: inputTokens,
+      output: outputTokens,
+    },
+  };
+}
+
 /**
  * Transform Codex SDK event to WebSocket message format
  * @param {object} event - SDK event
@@ -207,6 +236,11 @@ export async function queryCodex(command, options = {}, ws) {
     permissionMode = 'default'
   } = options;
 
+  const resolvedModel = await providerModelsService.resolveResumeModel(
+    'codex',
+    sessionId,
+    model,
+  );
   const userId = ws?.userId || null;
   const workingDirectory = cwd || projectPath || process.cwd();
   const { sandboxMode, approvalPolicy } = mapPermissionModeToCodexOptions(permissionMode);
@@ -228,7 +262,7 @@ export async function queryCodex(command, options = {}, ws) {
       skipGitRepoCheck: true,
       sandboxMode,
       approvalPolicy,
-      model
+      model: resolvedModel
     };
 
     // Start or resume thread
@@ -318,9 +352,11 @@ export async function queryCodex(command, options = {}, ws) {
       }
 
       // Extract and send token usage if available (normalized to match Claude format)
-      if (event.type === 'turn.completed' && event.usage) {
-        const totalTokens = (event.usage.input_tokens || 0) + (event.usage.output_tokens || 0);
-        sendMessage(ws, createNormalizedMessage({ kind: 'status', text: 'token_budget', tokenBudget: { used: totalTokens, total: 200000 }, sessionId: capturedSessionId || sessionId || null, provider: 'codex' }));
+      if (event.type === 'turn.completed') {
+        const tokenBudget = extractCodexTokenBudget(event);
+        if (tokenBudget) {
+          sendMessage(ws, createNormalizedMessage({ kind: 'status', text: 'token_budget', tokenBudget, sessionId: capturedSessionId || sessionId || null, provider: 'codex' }));
+        }
       }
     }
 

package/server/opencode-cli.js

@@ -0,0 +1,336 @@
+import { spawn } from 'child_process';
+import fsSync from 'node:fs';
+
+import crossSpawn from 'cross-spawn';
+import Database from 'better-sqlite3';
+
+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 { createNormalizedMessage, getOpenCodeDatabasePath } from './shared/utils.js';
+
+const spawnFunction = process.platform === 'win32' ? crossSpawn : spawn;
+
+const activeOpenCodeProcesses = new Map();
+
+function readOpenCodeSessionId(event) {
+  if (!event || typeof event !== 'object') {
+    return null;
+  }
+
+  return event.sessionID || event.sessionId || null;
+}
+
+function readOpenCodeTokenUsage(sessionId) {
+  const dbPath = getOpenCodeDatabasePath();
+  if (!sessionId || !fsSync.existsSync(dbPath)) {
+    return null;
+  }
+
+  let db = null;
+  try {
+    db = new Database(dbPath, { readonly: true, fileMustExist: true });
+    const columns = db.prepare('PRAGMA table_info(session)').all();
+    const columnNames = new Set(columns.map((column) => column.name));
+    const requiredColumns = ['tokens_input', 'tokens_output', 'tokens_reasoning', 'tokens_cache_read', 'tokens_cache_write'];
+    if (!requiredColumns.every((column) => columnNames.has(column))) {
+      return null;
+    }
+
+    const row = db.prepare(`
+      SELECT
+        tokens_input AS inputTokens,
+        tokens_output AS outputTokens,
+        tokens_reasoning AS reasoningTokens,
+        tokens_cache_read AS cacheReadTokens,
+        tokens_cache_write AS cacheWriteTokens
+      FROM session
+      WHERE id = ?
+    `).get(sessionId);
+
+    if (!row) {
+      return null;
+    }
+
+    const inputTokens = Number(row.inputTokens || 0) + Number(row.cacheReadTokens || 0);
+    const outputTokens = Number(row.outputTokens || 0);
+    const used = Number(row.inputTokens || 0)
+      + outputTokens
+      + Number(row.reasoningTokens || 0)
+      + Number(row.cacheReadTokens || 0)
+      + Number(row.cacheWriteTokens || 0);
+    if (used <= 0) {
+      return null;
+    }
+
+    return {
+      used,
+      inputTokens,
+      outputTokens,
+      breakdown: {
+        input: inputTokens,
+        output: outputTokens,
+      },
+    };
+  } catch {
+    return null;
+  } finally {
+    if (db) {
+      db.close();
+    }
+  }
+}
+
+async function spawnOpenCode(command, options = {}, ws) {
+  return new Promise((resolve, reject) => {
+    const { sessionId, projectPath, cwd, model, sessionSummary } = options;
+    const workingDir = cwd || projectPath || process.cwd();
+    const processKey = sessionId || Date.now().toString();
+    let capturedSessionId = sessionId || null;
+    let sessionCreatedSent = false;
+    let stdoutLineBuffer = '';
+    let terminalNotificationSent = false;
+    let opencodeProcess = null;
+
+    const notifyTerminalState = ({ code = null, error = null } = {}) => {
+      if (terminalNotificationSent) {
+        return;
+      }
+
+      terminalNotificationSent = true;
+      const finalSessionId = capturedSessionId || sessionId || processKey;
+      if (code === 0 && !error) {
+        notifyRunStopped({
+          userId: ws?.userId || null,
+          provider: 'opencode',
+          sessionId: finalSessionId,
+          sessionName: sessionSummary,
+          stopReason: 'completed',
+        });
+        return;
+      }
+
+      notifyRunFailed({
+        userId: ws?.userId || null,
+        provider: 'opencode',
+        sessionId: finalSessionId,
+        sessionName: sessionSummary,
+        error: error || `OpenCode CLI exited with code ${code}`,
+      });
+    };
+
+    const registerSession = (nextSessionId) => {
+      if (!nextSessionId || capturedSessionId === nextSessionId) {
+        return;
+      }
+
+      capturedSessionId = nextSessionId;
+      if (processKey !== capturedSessionId && opencodeProcess) {
+        activeOpenCodeProcesses.delete(processKey);
+        activeOpenCodeProcesses.set(capturedSessionId, opencodeProcess);
+      }
+      if (opencodeProcess) {
+        opencodeProcess.sessionId = capturedSessionId;
+      }
+
+      if (ws.setSessionId && typeof ws.setSessionId === 'function') {
+        ws.setSessionId(capturedSessionId);
+      }
+
+      if (!sessionId && !sessionCreatedSent) {
+        sessionCreatedSent = true;
+        ws.send(createNormalizedMessage({
+          kind: 'session_created',
+          newSessionId: capturedSessionId,
+          sessionId: capturedSessionId,
+          provider: 'opencode',
+        }));
+      }
+    };
+
+    const processOpenCodeOutputLine = (line) => {
+      if (!line || !line.trim()) {
+        return;
+      }
+
+      let response;
+      try {
+        response = JSON.parse(line);
+      } catch {
+        ws.send(createNormalizedMessage({
+          kind: 'stream_delta',
+          content: line,
+          sessionId: capturedSessionId || sessionId || null,
+          provider: 'opencode',
+        }));
+        return;
+      }
+
+      try {
+        registerSession(readOpenCodeSessionId(response));
+        const normalized = sessionsService.normalizeMessage(
+          'opencode',
+          response,
+          capturedSessionId || sessionId || null,
+        );
+        for (const msg of normalized) {
+          ws.send(msg);
+        }
+      } catch (error) {
+        const errorContent = error instanceof Error ? error.message : String(error);
+        console.error('[OpenCode] Failed to process JSON output:', errorContent);
+        ws.send(createNormalizedMessage({
+          kind: 'error',
+          content: errorContent,
+          sessionId: capturedSessionId || sessionId || null,
+          provider: 'opencode',
+        }));
+      }
+    };
+
+    void providerModelsService.resolveResumeModel('opencode', sessionId, model).then((resolvedModel) => {
+      const args = ['run', '--format', 'json'];
+      if (sessionId) {
+        args.push('--session', sessionId);
+      }
+      if (resolvedModel) {
+        args.push('--model', resolvedModel);
+      }
+      if (command && command.trim()) {
+        args.push(command.trim());
+      }
+
+      opencodeProcess = spawnFunction('opencode', args, {
+        cwd: workingDir,
+        stdio: ['pipe', 'pipe', 'pipe'],
+        env: { ...process.env },
+      });
+
+      activeOpenCodeProcesses.set(processKey, opencodeProcess);
+      opencodeProcess.sessionId = processKey;
+      opencodeProcess.stdin.end();
+
+      opencodeProcess.stdout.on('data', (data) => {
+        stdoutLineBuffer += data.toString();
+        const completeLines = stdoutLineBuffer.split(/\r?\n/);
+        stdoutLineBuffer = completeLines.pop() || '';
+
+        completeLines.forEach((line) => {
+          processOpenCodeOutputLine(line.trim());
+        });
+      });
+
+      opencodeProcess.stderr.on('data', (data) => {
+        const stderrText = data.toString();
+        if (!stderrText.trim()) {
+          return;
+        }
+
+        ws.send(createNormalizedMessage({
+          kind: 'error',
+          content: stderrText,
+          sessionId: capturedSessionId || sessionId || null,
+          provider: 'opencode',
+        }));
+      });
+
+      opencodeProcess.on('close', async (code) => {
+        const finalSessionId = capturedSessionId || sessionId || processKey;
+        activeOpenCodeProcesses.delete(finalSessionId);
+        activeOpenCodeProcesses.delete(processKey);
+
+        if (stdoutLineBuffer.trim()) {
+          processOpenCodeOutputLine(stdoutLineBuffer.trim());
+          stdoutLineBuffer = '';
+        }
+
+        const tokenBudget = readOpenCodeTokenUsage(finalSessionId);
+        if (tokenBudget) {
+          ws.send(createNormalizedMessage({
+            kind: 'status',
+            text: 'token_budget',
+            tokenBudget,
+            sessionId: finalSessionId,
+            provider: 'opencode',
+          }));
+        }
+
+        ws.send(createNormalizedMessage({
+          kind: 'complete',
+          exitCode: code,
+          isNewSession: !sessionId && !!command,
+          sessionId: finalSessionId,
+          provider: 'opencode',
+        }));
+
+        if (code === 0) {
+          notifyTerminalState({ code });
+          resolve();
+          return;
+        }
+
+        if (code === 127 || code === null) {
+          const installed = await providerAuthService.isProviderInstalled('opencode');
+          if (!installed) {
+            ws.send(createNormalizedMessage({
+              kind: 'error',
+              content: 'OpenCode CLI is not installed. Install it from https://opencode.ai/docs/',
+              sessionId: finalSessionId,
+              provider: 'opencode',
+            }));
+          }
+        }
+
+        notifyTerminalState({ code });
+        reject(new Error(code === null ? 'OpenCode CLI process was terminated' : `OpenCode CLI exited with code ${code}`));
+      });
+
+      opencodeProcess.on('error', async (error) => {
+        const finalSessionId = capturedSessionId || sessionId || processKey;
+        activeOpenCodeProcesses.delete(finalSessionId);
+        activeOpenCodeProcesses.delete(processKey);
+
+        const installed = await providerAuthService.isProviderInstalled('opencode');
+        const errorContent = !installed
+          ? 'OpenCode CLI is not installed. Install it from https://opencode.ai/docs/'
+          : error.message;
+
+        ws.send(createNormalizedMessage({
+          kind: 'error',
+          content: errorContent,
+          sessionId: finalSessionId,
+          provider: 'opencode',
+        }));
+        notifyTerminalState({ error });
+        reject(error);
+      });
+    }).catch(reject);
+  });
+}
+
+function abortOpenCodeSession(sessionId) {
+  const process = activeOpenCodeProcesses.get(sessionId);
+  if (!process) {
+    return false;
+  }
+
+  process.kill('SIGTERM');
+  activeOpenCodeProcesses.delete(sessionId);
+  return true;
+}
+
+function isOpenCodeSessionActive(sessionId) {
+  return activeOpenCodeProcesses.has(sessionId);
+}
+
+function getActiveOpenCodeSessions() {
+  return Array.from(activeOpenCodeProcesses.keys());
+}
+
+export {
+  spawnOpenCode,
+  abortOpenCodeSession,
+  isOpenCodeSessionActive,
+  getActiveOpenCodeSessions,
+};