@pixelbyte-software/pixcode 1.36.1 → 1.36.3

package/scripts/smoke/provider-rest-api.mjs

@@ -0,0 +1,124 @@
+#!/usr/bin/env node
+
+import process from 'node:process';
+
+const apiUrl = (process.env.PIXCODE_API_URL || 'http://127.0.0.1:3001').replace(/\/$/, '');
+const apiKey = process.env.PIXCODE_API_KEY || process.env.PIXCODE_AGENT_API_KEY || '';
+const providers = (process.env.PIXCODE_PROVIDERS || 'claude,cursor,codex,gemini,qwen,opencode')
+  .split(',')
+  .map((provider) => provider.trim())
+  .filter(Boolean);
+const projectPath = process.env.PIXCODE_PROJECT_PATH || process.cwd();
+const message = process.env.PIXCODE_SMOKE_MESSAGE
+  || 'Reply with exactly "pixcode-smoke-ok". Do not edit files.';
+const timeoutMs = Number(process.env.PIXCODE_SMOKE_TIMEOUT_MS || 180000);
+const modelMap = parseModelMap(process.env.PIXCODE_PROVIDER_MODELS || '{}');
+
+if (!apiKey) {
+  console.error('PIXCODE_API_KEY is required. Create one in Settings -> API Keys and rerun.');
+  process.exit(2);
+}
+
+const results = [];
+
+for (const provider of providers) {
+  const startedAt = Date.now();
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+
+  try {
+    const body = {
+      provider,
+      projectPath,
+      message,
+      stream: false,
+      cleanup: false,
+    };
+    if (modelMap[provider]) {
+      body.model = modelMap[provider];
+    }
+
+    const response = await fetch(`${apiUrl}/api/agent`, {
+      method: 'POST',
+      headers: {
+        Authorization: `Bearer ${apiKey}`,
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify(body),
+      signal: controller.signal,
+    });
+
+    const text = await response.text();
+    const payload = safeJson(text);
+    const assistantText = extractAssistantText(payload);
+    const ok = response.ok && payload?.success === true && assistantText.trim().length > 0;
+
+    results.push({
+      provider,
+      status: ok ? 'ok' : 'provider-error',
+      httpStatus: response.status,
+      success: Boolean(payload?.success),
+      durationMs: Date.now() - startedAt,
+      sessionId: payload?.sessionId || null,
+      assistantPreview: assistantText.trim().slice(0, 240),
+      error: ok ? null : (payload?.error || payload?.rawError || text.slice(0, 500)),
+    });
+  } catch (error) {
+    results.push({
+      provider,
+      status: error?.name === 'AbortError' ? 'timeout' : 'transport-error',
+      httpStatus: null,
+      success: false,
+      durationMs: Date.now() - startedAt,
+      sessionId: null,
+      assistantPreview: '',
+      error: error?.message || String(error),
+    });
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+console.log(JSON.stringify({ apiUrl, projectPath, results }, null, 2));
+process.exit(results.every((result) => result.status === 'ok') ? 0 : 1);
+
+function parseModelMap(raw) {
+  try {
+    const parsed = JSON.parse(raw);
+    return parsed && typeof parsed === 'object' && !Array.isArray(parsed) ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+
+function safeJson(text) {
+  try {
+    return JSON.parse(text);
+  } catch {
+    return null;
+  }
+}
+
+function extractAssistantText(payload) {
+  if (!payload || !Array.isArray(payload.messages)) return '';
+
+  const chunks = [];
+  for (const messageItem of payload.messages) {
+    if (messageItem?.type !== 'assistant') continue;
+    const content = messageItem.message?.content;
+    if (typeof content === 'string') {
+      chunks.push(content);
+      continue;
+    }
+    if (Array.isArray(content)) {
+      for (const part of content) {
+        if (typeof part === 'string') {
+          chunks.push(part);
+        } else if (part?.type === 'text' && typeof part.text === 'string') {
+          chunks.push(part.text);
+        }
+      }
+    }
+  }
+  return chunks.join('');
+}

package/scripts/smoke/update-ux.mjs

@@ -0,0 +1,55 @@
+#!/usr/bin/env node
+
+import { readFileSync } from 'node:fs';
+
+const checks = [
+  {
+    name: 'update frequency defaults to 30 minutes',
+    file: 'src/utils/updateCheckPreferences.ts',
+    test: (source) => (
+      source.includes("export type UpdateCheckFrequency = 'off' | '30m' |")
+      && source.includes("{ value: '30m'")
+      && /DEFAULT_UPDATE_CHECK_PREFERENCES[\s\S]*frequency:\s*'30m'/.test(source)
+    ),
+  },
+  {
+    name: 'sidebar opens the version modal when an update is detected',
+    file: 'src/components/sidebar/view/Sidebar.tsx',
+    test: (source) => (
+      source.includes('PIXCODE_UPDATE_AVAILABLE_EVENT')
+      && source.includes('setShowVersionModal(true)')
+      && source.includes('updateAvailable')
+    ),
+  },
+  {
+    name: 'version modal supports release-notes-only opens',
+    file: 'src/components/version-upgrade/view/VersionUpgradeModal.tsx',
+    test: (source) => (
+      source.includes('isUpdateAvailable')
+      && source.includes('versionUpdate.releaseNotesTitle')
+      && source.includes('showUpdateActions')
+    ),
+  },
+  {
+    name: 'desktop splash makes startup update work visible',
+    file: 'desktop/electron/main.cjs',
+    test: (source) => (
+      source.includes('Checking for updates before launch')
+      && source.includes('Applying Pixcode update')
+    ),
+  },
+];
+
+const failures = [];
+
+for (const check of checks) {
+  const source = readFileSync(check.file, 'utf8');
+  if (!check.test(source)) failures.push(check.name);
+}
+
+if (failures.length > 0) {
+  console.error(`Update UX smoke failed:\n- ${failures.join('\n- ')}`);
+  process.exit(1);
+}
+
+console.log('update UX smoke passed');

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

@@ -193,16 +193,55 @@ export class OpencodeSessionsProvider implements IProviderSessions {
     }
 
     const normalized: NormalizedMessage[] = [];
-    for (const raw of rawMessages) {
+    for (let i = 0; i < rawMessages.length; i++) {
+      const raw = rawMessages[i];
       const ts = raw.timestamp || new Date().toISOString();
-      const baseId = raw.uuid || raw.id || generateMessageId('opencode');
+      const baseId = raw.uuid || raw.id || `${PROVIDER}_${sessionId}_${i}`;
       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()) {
+      if (Array.isArray(content)) {
+        for (let partIdx = 0; partIdx < content.length; partIdx++) {
+          const part = readObjectRecord(content[partIdx]);
+          if (!part) continue;
+          if (part.type === 'text' && typeof part.text === 'string' && part.text.trim()) {
+            normalized.push(createNormalizedMessage({
+              id: `${baseId}_${partIdx}`,
+              sessionId,
+              timestamp: ts,
+              provider: PROVIDER,
+              kind: 'text',
+              role: normalizedRole,
+              content: part.text,
+            }));
+          } else if (part.type === 'tool_use') {
+            normalized.push(createNormalizedMessage({
+              id: `${baseId}_${partIdx}`,
+              sessionId,
+              timestamp: ts,
+              provider: PROVIDER,
+              kind: 'tool_use',
+              toolName: String(part.name || ''),
+              toolInput: part.input || {},
+              toolId: String(part.id || `${baseId}_${partIdx}`),
+            }));
+          } else if (part.type === 'tool_result') {
+            normalized.push(createNormalizedMessage({
+              id: `${baseId}_${partIdx}`,
+              sessionId,
+              timestamp: ts,
+              provider: PROVIDER,
+              kind: 'tool_result',
+              toolId: String(part.tool_use_id || ''),
+              content: part.content === undefined || part.content === null ? '' : String(part.content),
+              isError: Boolean(part.is_error),
+            }));
+          }
+        }
+      } else if (typeof content === 'string' && content.trim()) {
         normalized.push(createNormalizedMessage({
           id: baseId,
           sessionId,
@@ -215,6 +254,21 @@ export class OpencodeSessionsProvider implements IProviderSessions {
       }
     }
 
+    const toolResultMap = new Map<string, NormalizedMessage>();
+    for (const msg of normalized) {
+      if (msg.kind === 'tool_result' && msg.toolId) {
+        toolResultMap.set(msg.toolId, msg);
+      }
+    }
+    for (const msg of normalized) {
+      if (msg.kind === 'tool_use' && msg.toolId && toolResultMap.has(msg.toolId)) {
+        const toolResult = toolResultMap.get(msg.toolId);
+        if (toolResult) {
+          msg.toolResult = { content: toolResult.content, isError: toolResult.isError };
+        }
+      }
+    }
+
     const start = Math.max(0, offset);
     const pageLimit = limit === null ? null : Math.max(0, limit);
     const messages = pageLimit === null

package/server/opencode-cli.js

@@ -184,6 +184,20 @@ async function spawnOpencode(command, options = {}, ws) {
 
         let terminalNotificationSent = false;
         let terminalFailureReason = null;
+        let terminalFailurePersisted = false;
+
+        const persistTerminalFailure = (message) => {
+            const content = typeof message === 'string' && message.trim()
+                ? message.trim()
+                : null;
+            if (!content || terminalFailurePersisted) return;
+
+            const finalSessionId = capturedSessionId || sessionId || processKey;
+            if (!finalSessionId) return;
+
+            sessionManager.addMessage(finalSessionId, 'assistant', content);
+            terminalFailurePersisted = true;
+        };
 
         const notifyTerminalState = ({ code = null, error = null } = {}) => {
             if (terminalNotificationSent) return;
@@ -277,6 +291,9 @@ async function spawnOpencode(command, options = {}, ws) {
                         }
                     }
                 },
+                onError: (content) => {
+                    terminalFailureReason = content || 'OpenCode streaming error';
+                },
             });
         }
 
@@ -338,6 +355,7 @@ async function spawnOpencode(command, options = {}, ws) {
                 friendly = 'OpenCode upstream call failed. Clearing `~/.cache/opencode` and retrying usually resolves this.';
             }
 
+            terminalFailureReason = friendly;
             const socketSessionId = typeof ws.getSessionId === 'function' ? ws.getSessionId() : (capturedSessionId || sessionId);
             ws.send(createNormalizedMessage({ kind: 'error', content: friendly, sessionId: socketSessionId, provider: 'opencode' }));
         });
@@ -355,6 +373,8 @@ async function spawnOpencode(command, options = {}, ws) {
 
             if (finalSessionId && assistantBlocks.length > 0) {
                 sessionManager.addMessage(finalSessionId, 'assistant', assistantBlocks);
+            } else if (terminalFailureReason) {
+                persistTerminalFailure(terminalFailureReason);
             }
 
             ws.send(createNormalizedMessage({ kind: 'complete', exitCode: code, isNewSession: !sessionId && !!command, sessionId: finalSessionId, provider: 'opencode' }));
@@ -376,9 +396,11 @@ async function spawnOpencode(command, options = {}, ws) {
                     const installed = await providerAuthService.isProviderInstalled('opencode');
                     if (!installed) {
                         const socketSessionId = typeof ws.getSessionId === 'function' ? ws.getSessionId() : finalSessionId;
+                        const installMessage = 'OpenCode CLI is not installed. Install it from the Settings → Agents → OpenCode tab, or run: npm install -g opencode-ai';
+                        terminalFailureReason = installMessage;
                         ws.send(createNormalizedMessage({
                             kind: 'error',
-                            content: 'OpenCode CLI is not installed. Install it from the Settings → Agents → OpenCode tab, or run: npm install -g opencode-ai',
+                            content: installMessage,
                             sessionId: socketSessionId,
                             provider: 'opencode',
                         }));
@@ -404,6 +426,7 @@ async function spawnOpencode(command, options = {}, ws) {
 
             const errorSessionId = typeof ws.getSessionId === 'function' ? ws.getSessionId() : finalSessionId;
             ws.send(createNormalizedMessage({ kind: 'error', content: errorContent, sessionId: errorSessionId, provider: 'opencode' }));
+            persistTerminalFailure(errorContent);
             // Always emit `complete` so the UI's "Processing..." state clears
             // even when spawn fails (ENOENT, EACCES) and `close` never fires.
             ws.send(createNormalizedMessage({ kind: 'complete', exitCode: 1, isNewSession: !sessionId && !!command, sessionId: errorSessionId, provider: 'opencode' }));

package/server/opencode-response-handler.js

@@ -27,6 +27,7 @@ class OpencodeResponseHandler {
     this.onInit = options.onInit || null;
     this.onToolUse = options.onToolUse || null;
     this.onToolResult = options.onToolResult || null;
+    this.onError = options.onError || null;
     this.capturedCliSessionId = null;
   }
 
@@ -84,6 +85,9 @@ class OpencodeResponseHandler {
 
     const normalized = sessionsService.normalizeMessage('opencode', event, sid);
     for (const msg of normalized) {
+      if (msg.kind === 'error' && this.onError) {
+        this.onError(msg.content || 'OpenCode streaming error');
+      }
       this.ws.send(msg);
     }
   }

package/server/routes/agent.js

@@ -268,7 +268,7 @@ function describeProviderFailure(rawError, provider) {
     details.category = 'auth';
     details.title = `${name} is not authenticated or the selected model is not allowed.`;
     details.action = 'Reconnect this provider in Settings, refresh the CLI login, or choose a model enabled for the account.';
-  } else if (/(not installed|command not found|enoent|spawn .* enoent|executable file not found)/i.test(rawMessage)) {
+  } else if (/(not installed|command not found|enoent|spawn .* enoent|executable file not found|exited with code 127)/i.test(rawMessage)) {
     details.category = 'missing_cli';
     details.title = `${name} CLI is not installed or not on PATH.`;
     details.action = 'Install the CLI from Settings -> Agents or set the matching CLI path environment variable.';
@@ -1411,8 +1411,11 @@ router.post('/', validateExternalApiKey, async (req, res) => {
       if (writer && typeof writer.getAssistantMessages === 'function') {
         try {
           collectedMessages = writer.getAssistantMessages();
-          const errEntry = collectedMessages.find((m) => m.type === 'error');
-          if (errEntry) collectedError = errEntry.content;
+          const errorText = collectedMessages
+            .filter((m) => m.type === 'error' && typeof m.content === 'string' && m.content.trim())
+            .map((m) => m.content.trim())
+            .join('\n');
+          if (errorText) collectedError = errorText;
         } catch { /* ignore — fall back to error.message */ }
       }
       const failureDetails = describeProviderFailure(collectedError || error.message, provider);