@pixelbyte-software/pixcode 1.31.13 → 1.32.0

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

@@ -0,0 +1,126 @@
+import os from 'node:os';
+import path from 'node:path';
+
+import { McpProvider } from '@/modules/providers/shared/mcp/mcp.provider.js';
+import type { McpScope, ProviderMcpServer, UpsertProviderMcpServerInput } from '@/shared/types.js';
+import {
+  AppError,
+  readJsonConfig,
+  readObjectRecord,
+  readOptionalString,
+  readStringArray,
+  readStringRecord,
+  writeJsonConfig,
+} from '@/shared/utils.js';
+
+/**
+ * OpenCode MCP provider.
+ *
+ * OpenCode's MCP servers live under the top-level `mcp` key in
+ * `opencode.json` (global at `~/.config/opencode/opencode.json`, project at
+ * `<workspace>/opencode.json`). Each entry is either a local stdio command
+ * (`{ command, args, env }`) or a remote server (`{ type: "remote", url,
+ * headers, enabled }`). OpenCode's schema also supports an `enabled: false`
+ * flag we preserve on write but don't surface in the UI yet.
+ */
+export class OpencodeMcpProvider extends McpProvider {
+  constructor() {
+    super('opencode', ['user', 'project'], ['stdio', 'http', 'sse']);
+  }
+
+  protected async readScopedServers(scope: McpScope, workspacePath: string): Promise<Record<string, unknown>> {
+    const filePath = scope === 'user'
+      ? path.join(os.homedir(), '.config', 'opencode', 'opencode.json')
+      : path.join(workspacePath, 'opencode.json');
+    const config = await readJsonConfig(filePath);
+    return readObjectRecord(config.mcp) ?? {};
+  }
+
+  protected async writeScopedServers(
+    scope: McpScope,
+    workspacePath: string,
+    servers: Record<string, unknown>,
+  ): Promise<void> {
+    const filePath = scope === 'user'
+      ? path.join(os.homedir(), '.config', 'opencode', 'opencode.json')
+      : path.join(workspacePath, 'opencode.json');
+    const config = await readJsonConfig(filePath);
+    config.mcp = servers;
+    await writeJsonConfig(filePath, config);
+  }
+
+  protected buildServerConfig(input: UpsertProviderMcpServerInput): Record<string, unknown> {
+    if (input.transport === 'stdio') {
+      if (!input.command?.trim()) {
+        throw new AppError('command is required for stdio MCP servers.', {
+          code: 'MCP_COMMAND_REQUIRED',
+          statusCode: 400,
+        });
+      }
+      return {
+        type: 'local',
+        command: input.command,
+        args: input.args ?? [],
+        env: input.env ?? {},
+        cwd: input.cwd,
+        enabled: true,
+      };
+    }
+
+    if (!input.url?.trim()) {
+      throw new AppError('url is required for http/sse MCP servers.', {
+        code: 'MCP_URL_REQUIRED',
+        statusCode: 400,
+      });
+    }
+
+    return {
+      type: 'remote',
+      url: input.url,
+      headers: input.headers ?? {},
+      enabled: true,
+    };
+  }
+
+  protected normalizeServerConfig(
+    scope: McpScope,
+    name: string,
+    rawConfig: unknown,
+  ): ProviderMcpServer | null {
+    if (!rawConfig || typeof rawConfig !== 'object') {
+      return null;
+    }
+
+    const config = rawConfig as Record<string, unknown>;
+    const opencodeType = readOptionalString(config.type);
+
+    // Local (stdio) entries — either type: "local" explicitly or any entry
+    // with a command field (pre-type schemas).
+    if (opencodeType === 'local' || typeof config.command === 'string') {
+      return {
+        provider: 'opencode',
+        name,
+        scope,
+        transport: 'stdio',
+        command: typeof config.command === 'string' ? config.command : '',
+        args: readStringArray(config.args),
+        env: readStringRecord(config.env),
+        cwd: readOptionalString(config.cwd),
+      };
+    }
+
+    // Remote entries — type: "remote" or any entry with a url field.
+    if (opencodeType === 'remote' || typeof config.url === 'string') {
+      return {
+        provider: 'opencode',
+        name,
+        scope,
+        transport: 'http',
+        url: typeof config.url === 'string' ? config.url : '',
+        headers: readStringRecord(config.headers),
+      };
+    }
+
+    return null;
+  }
+}

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

@@ -0,0 +1,155 @@
+import sessionManager from '@/sessionManager.js';
+import type { IProviderSessions } from '@/shared/interfaces.js';
+import type { AnyRecord, FetchHistoryOptions, FetchHistoryResult, NormalizedMessage } from '@/shared/types.js';
+import { createNormalizedMessage, generateMessageId, readObjectRecord } from '@/shared/utils.js';
+
+const PROVIDER = 'opencode';
+
+/**
+ * OpenCode sessions provider.
+ *
+ * OpenCode persists session transcripts under
+ * `~/.local/share/opencode/project/<project-slug>/sessions/` (XDG data dir).
+ * The on-disk format is JSON per session — different from Gemini/Qwen's
+ * single-file-per-conversation layout. For the initial integration we
+ * read transcripts only from the in-memory sessionManager (freshly
+ * captured streams); restoring historical sessions from disk will land
+ * in a follow-up once the exact schema is pinned.
+ *
+ * Stream events follow the headless `opencode serve` API contract —
+ * messages carry `{ role, parts: [{ type: text|tool-use|tool-result, ... }] }`.
+ */
+export class OpencodeSessionsProvider implements IProviderSessions {
+  normalizeMessage(rawMessage: unknown, sessionId: string | null): NormalizedMessage[] {
+    const raw = readObjectRecord(rawMessage);
+    if (!raw) return [];
+
+    const ts = raw.timestamp || new Date().toISOString();
+    const baseId = raw.uuid || raw.id || generateMessageId('opencode');
+
+    if (raw.type === 'message' && raw.role === 'assistant') {
+      const content = raw.content || '';
+      const messages: NormalizedMessage[] = [];
+      if (content) {
+        messages.push(createNormalizedMessage({
+          id: baseId,
+          sessionId,
+          timestamp: ts,
+          provider: PROVIDER,
+          kind: 'stream_delta',
+          content,
+        }));
+      }
+      if (raw.delta !== true) {
+        messages.push(createNormalizedMessage({
+          sessionId,
+          timestamp: ts,
+          provider: PROVIDER,
+          kind: 'stream_end',
+        }));
+      }
+      return messages;
+    }
+
+    if (raw.type === 'tool_use' || raw.type === 'tool-use') {
+      return [createNormalizedMessage({
+        id: baseId,
+        sessionId,
+        timestamp: ts,
+        provider: PROVIDER,
+        kind: 'tool_use',
+        toolName: raw.tool_name || raw.name,
+        toolInput: raw.parameters || raw.input || {},
+        toolId: raw.tool_id || raw.id || baseId,
+      })];
+    }
+
+    if (raw.type === 'tool_result' || raw.type === 'tool-result') {
+      return [createNormalizedMessage({
+        id: baseId,
+        sessionId,
+        timestamp: ts,
+        provider: PROVIDER,
+        kind: 'tool_result',
+        toolId: raw.tool_id || raw.toolCallId || '',
+        content: raw.output === undefined ? '' : String(raw.output),
+        isError: raw.status === 'error' || Boolean(raw.isError),
+      })];
+    }
+
+    if (raw.type === 'result') {
+      return [createNormalizedMessage({
+        sessionId,
+        timestamp: ts,
+        provider: PROVIDER,
+        kind: 'stream_end',
+      })];
+    }
+
+    if (raw.type === 'error') {
+      return [createNormalizedMessage({
+        id: baseId,
+        sessionId,
+        timestamp: ts,
+        provider: PROVIDER,
+        kind: 'error',
+        content: raw.error || raw.message || 'Unknown OpenCode streaming error',
+      })];
+    }
+
+    return [];
+  }
+
+  async fetchHistory(
+    sessionId: string,
+    options: FetchHistoryOptions = {},
+  ): Promise<FetchHistoryResult> {
+    const { limit = null, offset = 0 } = options;
+
+    let rawMessages: AnyRecord[] = [];
+    try {
+      rawMessages = sessionManager.getSessionMessages(sessionId) as AnyRecord[];
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.warn(`[OpencodeProvider] Failed to load session ${sessionId}:`, message);
+      return { messages: [], total: 0, hasMore: false, offset: 0, limit: null };
+    }
+
+    const normalized: NormalizedMessage[] = [];
+    for (const raw of rawMessages) {
+      const ts = raw.timestamp || new Date().toISOString();
+      const baseId = raw.uuid || raw.id || generateMessageId('opencode');
+      const role = raw.message?.role || raw.role;
+      const content = raw.message?.content || raw.content;
+
+      if (!role || !content) continue;
+      const normalizedRole = role === 'user' ? 'user' : 'assistant';
+
+      if (typeof content === 'string' && content.trim()) {
+        normalized.push(createNormalizedMessage({
+          id: baseId,
+          sessionId,
+          timestamp: ts,
+          provider: PROVIDER,
+          kind: 'text',
+          role: normalizedRole,
+          content,
+        }));
+      }
+    }
+
+    const start = Math.max(0, offset);
+    const pageLimit = limit === null ? null : Math.max(0, limit);
+    const messages = pageLimit === null
+      ? normalized.slice(start)
+      : normalized.slice(start, start + pageLimit);
+
+    return {
+      messages,
+      total: normalized.length,
+      hasMore: pageLimit === null ? false : start + pageLimit < normalized.length,
+      offset: start,
+      limit: pageLimit,
+    };
+  }
+}

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

@@ -0,0 +1,29 @@
+import { AbstractProvider } from '@/modules/providers/shared/base/abstract.provider.js';
+import { OpencodeProviderAuth } from '@/modules/providers/list/opencode/opencode-auth.provider.js';
+import { OpencodeMcpProvider } from '@/modules/providers/list/opencode/opencode-mcp.provider.js';
+import { OpencodeSessionsProvider } from '@/modules/providers/list/opencode/opencode-sessions.provider.js';
+import type { IProviderAuth, IProviderSessions } from '@/shared/interfaces.js';
+
+/**
+ * OpenCode provider.
+ *
+ * OpenCode (npm package: `opencode-ai`, binary: `opencode`) is a
+ * multi-provider terminal coding agent. Unlike Claude/Codex/Gemini/Qwen
+ * it uses XDG paths:
+ *   - config: `~/.config/opencode/opencode.json`
+ *   - data:   `~/.local/share/opencode/` (auth.json, sessions, logs)
+ *
+ * Its permission system is granular (per-tool + per-pattern) rather than
+ * the 2/3-mode toggle other CLIs expose. We surface that through the
+ * Configuration tab and the opencode.json editor — the Permissions tab
+ * exposes high-level presets only.
+ */
+export class OpencodeProvider extends AbstractProvider {
+  readonly mcp = new OpencodeMcpProvider();
+  readonly auth: IProviderAuth = new OpencodeProviderAuth();
+  readonly sessions: IProviderSessions = new OpencodeSessionsProvider();
+
+  constructor() {
+    super('opencode');
+  }
+}

package/server/modules/providers/provider.registry.ts

@@ -2,6 +2,7 @@ import { ClaudeProvider } from '@/modules/providers/list/claude/claude.provider.
 import { CodexProvider } from '@/modules/providers/list/codex/codex.provider.js';
 import { CursorProvider } from '@/modules/providers/list/cursor/cursor.provider.js';
 import { GeminiProvider } from '@/modules/providers/list/gemini/gemini.provider.js';
+import { OpencodeProvider } from '@/modules/providers/list/opencode/opencode.provider.js';
 import { QwenProvider } from '@/modules/providers/list/qwen/qwen.provider.js';
 import type { IProvider } from '@/shared/interfaces.js';
 import type { LLMProvider } from '@/shared/types.js';
@@ -13,6 +14,7 @@ const providers: Record<LLMProvider, IProvider> = {
   cursor: new CursorProvider(),
   gemini: new GeminiProvider(),
   qwen: new QwenProvider(),
+  opencode: new OpencodeProvider(),
 };
 
 /**

package/server/modules/providers/provider.routes.ts

@@ -29,6 +29,7 @@ import {
   GEMINI_MODELS,
   QWEN_MODELS,
   CURSOR_MODELS,
+  OPENCODE_MODELS,
 } from '../../../shared/modelConstants.js';
 
 const STATIC_MODELS_BY_PROVIDER: Record<LLMProvider, Array<{ value: string; label: string }>> = {
@@ -37,6 +38,7 @@ const STATIC_MODELS_BY_PROVIDER: Record<LLMProvider, Array<{ value: string; labe
   cursor: CURSOR_MODELS.OPTIONS,
   gemini: GEMINI_MODELS.OPTIONS,
   qwen: QWEN_MODELS.OPTIONS,
+  opencode: OPENCODE_MODELS.OPTIONS,
 };
 import type { LLMProvider, McpScope, McpTransport, UpsertProviderMcpServerInput } from '@/shared/types.js';
 import { AppError, asyncHandler, createApiSuccessResponse } from '@/shared/utils.js';
@@ -68,6 +70,7 @@ const PROVIDER_INSTALL_PACKAGES: Record<LLMProvider, string | null> = {
   codex: '@openai/codex',
   gemini: '@google/gemini-cli',
   qwen: '@qwen-code/qwen-code',
+  opencode: 'opencode-ai',
   // Cursor ships via a bash script hosted at cursor.com; safer to ask
   // users to run it themselves than to pipe-to-bash from our server.
   cursor: null,
@@ -78,6 +81,7 @@ const PROVIDER_INSTALL_COMMANDS: Record<LLMProvider, string | null> = {
   codex: 'npm install -g @openai/codex',
   gemini: 'npm install -g @google/gemini-cli',
   qwen: 'npm install -g @qwen-code/qwen-code',
+  opencode: 'npm install -g opencode-ai',
   cursor: null,
 };
 

package/server/modules/providers/shared/provider-configs.ts

@@ -108,6 +108,30 @@ export const PROVIDER_CONFIG_FILES: Record<string, ProviderConfigFile[]> = {
       description: 'Environment variables (DASHSCOPE_API_KEY, OPENAI_API_KEY for OpenAI-compatible routes, …).',
     },
   ],
+  opencode: [
+    {
+      id: 'config',
+      label: 'opencode.json',
+      relativePath: '.config/opencode/opencode.json',
+      format: 'json',
+      description: 'Main OpenCode config — provider, model, MCP servers, permission rules, agents.',
+    },
+    {
+      id: 'tui',
+      label: 'tui.json',
+      relativePath: '.config/opencode/tui.json',
+      format: 'json',
+      description: 'Terminal UI preferences (theme, keybinds). Separate from the main config since 2026-02.',
+    },
+    {
+      id: 'auth',
+      label: 'auth.json',
+      relativePath: '.local/share/opencode/auth.json',
+      format: 'json',
+      readonly: true,
+      description: 'Provider credentials managed by `opencode auth login`. Read-only here; editing would corrupt stored OAuth tokens.',
+    },
+  ],
 };
 
 export const SUPPORTED_CONFIG_PROVIDERS = Object.keys(PROVIDER_CONFIG_FILES);

package/server/routes/auth.js

@@ -1,5 +1,9 @@
 import express from 'express';
-import bcrypt from 'bcrypt';
+// bcryptjs is a pure-JS drop-in (same hash/compare API, same output format)
+// — switching from native `bcrypt` here eliminated one C++ compile from
+// the install path. Existing $2a$/$2b$ hashes in the DB remain valid;
+// bcryptjs recognizes both prefixes so logins work across the swap.
+import bcrypt from 'bcryptjs';
 import { userDb, db } from '../database/db.js';
 import { generateToken, authenticateToken } from '../middleware/auth.js';
 

package/server/routes/network.js

@@ -2,8 +2,6 @@ import express from 'express';
 import os from 'os';
 
 import {
-  disableUpnp,
-  enableUpnp,
   getTunnelState,
   getUpnpState,
   startTunnel,
@@ -78,26 +76,20 @@ router.get('/external', (req, res) => {
   }
 });
 
-router.post('/upnp', async (req, res) => {
-  const port = resolveServerPort();
-  try {
-    const state = await enableUpnp({ port });
-    res.json({ success: true, upnp: state });
-  } catch (error) {
-    console.error('UPnP enable failed:', error);
-    res.status(502).json({ error: error?.message || 'UPnP enable failed', upnp: getUpnpState() });
-  }
+// UPnP endpoints removed in v1.32 (see external-access.js for rationale).
+// Clients hitting /upnp get a 410 so the UI can show a clear "moved to
+// tunnel" hint without mistaking the absence for a transient 404.
+router.post('/upnp', (_req, res) => {
+  res.status(410).json({
+    error: 'UPnP removed in v1.32 — use cloudflared or ngrok tunnels instead',
+    upnp: getUpnpState(),
+  });
 });
-
-router.delete('/upnp', async (req, res) => {
-  const port = resolveServerPort();
-  try {
-    const state = await disableUpnp({ port });
-    res.json({ success: true, upnp: state });
-  } catch (error) {
-    console.error('UPnP disable failed:', error);
-    res.status(502).json({ error: error?.message || 'UPnP disable failed', upnp: getUpnpState() });
-  }
+router.delete('/upnp', (_req, res) => {
+  res.status(410).json({
+    error: 'UPnP removed in v1.32 — use cloudflared or ngrok tunnels instead',
+    upnp: getUpnpState(),
+  });
 });
 
 router.post('/tunnel', async (req, res) => {