@pixelbyte-software/pixcode 1.35.4 → 1.36.0

package/server/modules/orchestration/workflows/workflow-runner.ts

@@ -896,6 +896,124 @@ class WorkflowRunner {
     }
   }
 
+  private fallbackAgentFor(run: WorkflowRun, node: WorkflowNode): AgentAssignment | undefined {
+    if (node.stage === 'fallback' || node.id.startsWith('fallback_')) {
+      return undefined;
+    }
+
+    const settings = getMetadataRecord(run.metadata, 'settings');
+    const fallbackAgentInstanceId = readString(settings.fallbackAgentInstanceId);
+    if (!fallbackAgentInstanceId || fallbackAgentInstanceId === node.agentInstanceId) {
+      return undefined;
+    }
+
+    return readAgentAssignments(run.metadata).find((agent) => agent.instanceId === fallbackAgentInstanceId);
+  }
+
+  private createFallbackNode(node: WorkflowNode, fallbackAgent: AgentAssignment, reason: string): WorkflowNode {
+    const fallbackSuffix = safeNodeId(fallbackAgent.instanceId, 'fallback');
+    return {
+      ...node,
+      id: `fallback_${node.id}_${fallbackSuffix}`,
+      adapterId: fallbackAgent.adapterId,
+      agentInstanceId: fallbackAgent.instanceId,
+      agentLabel: `${fallbackAgent.label} Fallback`,
+      assignment: `Fallback for ${node.agentLabel || node.id}`,
+      stage: 'fallback',
+      model: fallbackAgent.model,
+      permissionMode: fallbackAgent.permissionMode,
+      toolsSettings: fallbackAgent.toolsSettings,
+      prompt: [
+        'The previous CLI agent failed on this orchestration step.',
+        `Failed step: ${node.agentLabel || node.id}`,
+        `Failure: ${reason}`,
+        'Take over the same assignment as the backup CLI. Use the original goal and upstream context.',
+        'Do not repeat unrelated work; complete the failed step and report what you did.',
+        node.prompt,
+      ].join('\n'),
+      onFail: 'continue',
+    };
+  }
+
+  private async runFallbackAfterFailure(
+    node: WorkflowNode,
+    workflow: Workflow,
+    run: WorkflowRun,
+    outputs: Map<string, string>,
+    started: Set<string>,
+    completed: Set<string>,
+    reason: string,
+  ): Promise<boolean> {
+    const fallbackAgent = this.fallbackAgentFor(run, node);
+    if (!fallbackAgent) {
+      return false;
+    }
+    if (workflow.nodes.length + 1 > 64) {
+      run.metadata = {
+        ...run.metadata,
+        fallbackSkipped: `Workflow node limit reached after ${node.id}.`,
+      };
+      workflowStore.setRun(run);
+      return false;
+    }
+
+    let fallbackNode = this.createFallbackNode(node, fallbackAgent, reason);
+    let collision = 1;
+    while (workflow.nodes.some((candidate) => candidate.id === fallbackNode.id)) {
+      collision += 1;
+      fallbackNode = {
+        ...fallbackNode,
+        id: `${fallbackNode.id}_${collision}`,
+      };
+    }
+
+    const nodeIndex = workflow.nodes.findIndex((candidate) => candidate.id === node.id);
+    const runIndex = run.nodeRuns.findIndex((candidate) => candidate.nodeId === node.id);
+    if (nodeIndex >= 0) {
+      workflow.nodes.splice(nodeIndex + 1, 0, fallbackNode);
+    } else {
+      workflow.nodes.push(fallbackNode);
+    }
+    if (runIndex >= 0) {
+      run.nodeRuns.splice(runIndex + 1, 0, nodeRunFromNode(fallbackNode));
+    } else {
+      run.nodeRuns.push(nodeRunFromNode(fallbackNode));
+    }
+
+    const fallbackEvents = Array.isArray(run.metadata?.fallbackEvents)
+      ? run.metadata.fallbackEvents
+      : [];
+    run.metadata = {
+      ...run.metadata,
+      fallbackEvents: [
+        ...fallbackEvents,
+        {
+          nodeId: node.id,
+          fallbackNodeId: fallbackNode.id,
+          fallbackAgentInstanceId: fallbackAgent.instanceId,
+          reason,
+          startedAt: Date.now(),
+        },
+      ],
+    };
+    workflowStore.setRun(run);
+
+    await this.executeNode(fallbackNode, workflow, run, outputs, started, completed);
+
+    const fallbackRun = run.nodeRuns.find((candidate) => candidate.nodeId === fallbackNode.id);
+    if (fallbackRun?.status !== 'completed') {
+      return false;
+    }
+
+    const fallbackOutput = outputs.get(fallbackNode.id) || fallbackRun.outputText;
+    if (fallbackOutput) {
+      outputs.set(node.id, compactOutputForContext(fallbackOutput));
+    }
+    completed.add(node.id);
+    workflowStore.setRun(run);
+    return true;
+  }
+
   private maybeAddRepairCycle(
     node: WorkflowNode,
     workflow: Workflow,
@@ -1087,40 +1205,56 @@ class WorkflowRunner {
     const isolation = readIsolation(settings.isolation) ?? node.isolation ?? 'host';
     const keepAfterCompletion = readBoolean(settings.keepWorkspace) ?? true;
     const baseRef = readString(settings.baseRef) ?? 'HEAD';
-    const submit = await fetch(`${localA2ABaseUrl()}/tasks`, {
-      method: 'POST',
-      headers: { 'content-type': 'application/json' },
-      body: JSON.stringify({
-        adapterId: node.adapterId,
-        contextId: run.contextId,
-        message: {
-          messageId: newId('msg'),
-          role: 'user',
-          parts: [{ kind: 'text', text: prompt }],
-        },
-        metadata: {
-          workflowRunId: run.id,
-          workflowNodeId: node.id,
-          agentInstanceId: node.agentInstanceId,
-          agentLabel: node.agentLabel,
-          assignment: node.assignment,
-          model: node.model,
-          permissionMode: node.permissionMode,
-          toolsSettings: node.toolsSettings,
-          projectPath,
-          workspaceTarget: workspaceTargetMetadata(workspaceTarget),
-          workspace: {
-            kind: isolation,
+    let body: { id?: string; error?: { message?: string } };
+    try {
+      const submit = await fetch(`${localA2ABaseUrl()}/tasks`, {
+        method: 'POST',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify({
+          adapterId: node.adapterId,
+          contextId: run.contextId,
+          message: {
+            messageId: newId('msg'),
+            role: 'user',
+            parts: [{ kind: 'text', text: prompt }],
+          },
+          metadata: {
+            workflowRunId: run.id,
+            workflowNodeId: node.id,
+            agentInstanceId: node.agentInstanceId,
+            agentLabel: node.agentLabel,
+            assignment: node.assignment,
+            model: node.model,
+            permissionMode: node.permissionMode,
+            toolsSettings: node.toolsSettings,
             projectPath,
-            baseRef,
-            keepAfterCompletion,
+            workspaceTarget: workspaceTargetMetadata(workspaceTarget),
+            workspace: {
+              kind: isolation,
+              projectPath,
+              baseRef,
+              keepAfterCompletion,
+            },
           },
-        },
-      }),
-    });
-    const body = await submit.json() as { id?: string; error?: { message?: string } };
-    if (!submit.ok || !body.id) {
-      throw new Error(body.error?.message ?? `Workflow node ${node.id} submit failed.`);
+        }),
+      });
+      body = await submit.json() as { id?: string; error?: { message?: string } };
+      if (!submit.ok || !body.id) {
+        throw new Error(body.error?.message ?? `Workflow node ${node.id} submit failed.`);
+      }
+    } catch (error) {
+      nodeRun.finishedAt = Date.now();
+      nodeRun.status = 'failed';
+      nodeRun.error = error instanceof Error ? error.message : String(error);
+      workflowStore.setRun(run);
+      if (await this.runFallbackAfterFailure(node, workflow, run, outputs, started, completed, nodeRun.error)) {
+        return;
+      }
+      if (node.onFail === 'continue') {
+        completed.add(node.id);
+        return;
+      }
+      throw error;
     }
     nodeRun.a2aTaskId = body.id;
     workflowStore.setRun(run);
@@ -1160,6 +1294,9 @@ class WorkflowRunner {
         outputs.set(node.id, compactOutputForContext(nodeRun.outputText));
       }
       workflowStore.setRun(run);
+      if (await this.runFallbackAfterFailure(node, workflow, run, outputs, started, completed, nodeRun.error)) {
+        return;
+      }
       if (node.onFail === 'continue') {
         completed.add(node.id);
         return;
@@ -1192,6 +1329,9 @@ class WorkflowRunner {
     nodeRun.status = 'failed';
     nodeRun.error = result.error ?? `A2A task ended with ${result.state}`;
     workflowStore.setRun(run);
+    if (await this.runFallbackAfterFailure(node, workflow, run, outputs, started, completed, nodeRun.error)) {
+      return;
+    }
     if (node.onFail === 'continue') {
       if (nodeRun.outputText) {
         outputs.set(node.id, compactOutputForContext(nodeRun.outputText));

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

@@ -14,6 +14,8 @@ import {
  
 // @ts-ignore — plain-JS service
 import { getProviderModels, clearProviderModelCache } from '@/services/provider-models.js';
+// @ts-ignore — plain-JS service
+import { getProviderCliVersionStatus } from '@/services/provider-cli-versions.js';
  
 // @ts-ignore — plain-JS service
 import {
@@ -262,8 +264,13 @@ router.get(
   '/:provider/auth/status',
   asyncHandler(async (req: Request, res: Response) => {
     const provider = parseProvider(req.params.provider);
+    const forceRefresh = String(req.query.refresh || '').toLowerCase() === '1';
     const status = await providerAuthService.getProviderAuthStatus(provider);
-    res.json(createApiSuccessResponse(status));
+    const cliVersion = await getProviderCliVersionStatus(provider, {
+      installed: status.installed,
+      forceRefresh,
+    });
+    res.json(createApiSuccessResponse({ ...status, ...cliVersion }));
   }),
 );
 

package/server/routes/agent.js

@@ -19,6 +19,7 @@ import { CODEX_MODELS } from '../../shared/modelConstants.js';
 import { IS_PLATFORM } from '../constants/config.js';
 
 const router = express.Router();
+const isPixcodeApiKey = (token) => typeof token === 'string' && (token.startsWith('px_') || token.startsWith('ck_'));
 
 /**
  * Middleware to authenticate agent API requests.
@@ -49,18 +50,18 @@ const validateExternalApiKey = (req, res, next) => {
   }
 
   // Self-hosted mode: validate API key from any of the supported transports.
-  //   - Authorization: Bearer ck_... (added so /api/agent accepts the same
+  //   - Authorization: Bearer px_... (legacy ck_... still accepted)
   //     auth shape as the rest of the API, per the auth-unify in this turn)
-  //   - X-API-Key: ck_... (legacy, kept working)
-  //   - ?apiKey=ck_... (EventSource workaround)
+  //   - X-API-Key: px_...
+  //   - ?apiKey=px_... (EventSource workaround)
   const authHeader = req.headers['authorization'];
   const bearer = authHeader && authHeader.startsWith('Bearer ') ? authHeader.slice(7).trim() : null;
-  const apiKey = (bearer && bearer.startsWith('ck_') ? bearer : null)
+  const apiKey = (isPixcodeApiKey(bearer) ? bearer : null)
     || req.headers['x-api-key']
     || (typeof req.query.apiKey === 'string' ? req.query.apiKey : null);
 
   if (!apiKey) {
-    return res.status(401).json({ error: 'API key required (Authorization: Bearer ck_..., X-API-Key, or ?apiKey=)' });
+    return res.status(401).json({ error: 'API key required (Authorization: Bearer px_..., X-API-Key, or ?apiKey=)' });
   }
 
   const user = apiKeysDb.validateApiKey(apiKey);
@@ -230,6 +231,61 @@ function validateBranchName(branchName) {
   return { valid: true };
 }
 
+function providerDisplayName(provider) {
+  return ({
+    claude: 'Claude',
+    cursor: 'Cursor',
+    codex: 'Codex',
+    gemini: 'Gemini',
+    qwen: 'Qwen',
+    opencode: 'OpenCode',
+  })[provider] || 'Provider';
+}
+
+function describeProviderFailure(rawError, provider) {
+  const rawMessage = String(rawError || '').trim() || 'Provider returned no assistant text.';
+  const normalized = rawMessage.toLowerCase();
+  const name = providerDisplayName(provider);
+
+  const details = {
+    provider,
+    providerName: name,
+    category: 'provider_error',
+    title: `${name} could not answer.`,
+    action: 'Check the provider output, then retry with a shorter prompt or a different model.',
+    rawMessage,
+  };
+
+  if (/(balance|billing|quota|credit|insufficient|payment required|402|usage limit|spend limit)/i.test(rawMessage)) {
+    details.category = 'quota';
+    details.title = `${name} could not answer because the account has no available balance or quota.`;
+    details.action = 'Add credits, increase the provider usage limit, or switch to a free/available model.';
+  } else if (/(rate limit|too many requests|429|temporarily overloaded|resource exhausted)/i.test(rawMessage)) {
+    details.category = 'rate_limit';
+    details.title = `${name} is rate limited right now.`;
+    details.action = 'Wait a bit, reduce parallel runs, or switch to another provider/model.';
+  } else if (/(unauthorized|forbidden|permission_denied|permission denied|api key|token|oauth|login|not authenticated|401|403|invalid credentials)/i.test(rawMessage)) {
+    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)) {
+    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.';
+  } else if (/(timeout|timed out|aborted|etimedout|deadline)/i.test(rawMessage)) {
+    details.category = 'timeout';
+    details.title = `${name} timed out before returning a complete answer.`;
+    details.action = 'Retry with a shorter request, reduce orchestration parallelism, or inspect the provider session log.';
+  } else if (normalized.includes('no assistant text') || normalized.includes('empty')) {
+    details.category = 'no_output';
+    details.title = `${name} finished without visible assistant text.`;
+    details.action = 'Retry once; if it repeats, check provider stderr/session logs because the CLI may have exited before streaming text.';
+  }
+
+  details.message = `${details.title} ${details.action}`;
+  return details;
+}
+
 /**
  * Get recent commit messages from a repository
  * @param {string} projectPath - Path to the git repository
@@ -1276,6 +1332,12 @@ router.post('/', validateExternalApiKey, async (req, res) => {
         (m) => m.type === 'assistant' && m.message?.content?.some?.((p) => p.type === 'text' && p.text)
       );
       const succeeded = !errorEntry && (hasAssistantText || assistantMessages.some((m) => m.type === 'tool_use' || m.type === 'tool_result'));
+      const failureDetails = succeeded
+        ? null
+        : describeProviderFailure(
+          errorEntry?.content || 'Provider returned no assistant text. Check backend log for details.',
+          provider,
+        );
 
       const response = {
         success: succeeded,
@@ -1284,10 +1346,10 @@ router.post('/', validateExternalApiKey, async (req, res) => {
         tokens: tokenSummary,
         projectPath: finalProjectPath
       };
-      if (errorEntry) {
-        response.error = errorEntry.content;
-      } else if (!succeeded) {
-        response.error = 'Provider returned no assistant text. Check backend log for details.';
+      if (failureDetails) {
+        response.error = failureDetails.message;
+        response.rawError = failureDetails.rawMessage;
+        response.errorDetails = failureDetails;
       }
 
       // Add branch/PR info if created
@@ -1353,10 +1415,13 @@ router.post('/', validateExternalApiKey, async (req, res) => {
           if (errEntry) collectedError = errEntry.content;
         } catch { /* ignore — fall back to error.message */ }
       }
+      const failureDetails = describeProviderFailure(collectedError || error.message, provider);
       res.status(502).json({
         success: false,
         sessionId: writer && typeof writer.getSessionId === 'function' ? writer.getSessionId() : null,
-        error: collectedError || error.message,
+        error: failureDetails.message,
+        rawError: failureDetails.rawMessage,
+        errorDetails: failureDetails,
         wrapperError: collectedError ? error.message : undefined,
         messages: collectedMessages,
       });

package/server/services/notification-orchestrator.js

@@ -7,7 +7,8 @@ import { notifyUser as notifyTelegramUser } from './telegram/bot.js';
 const KIND_TO_PREF_KEY = {
   action_required: 'actionRequired',
   stop: 'stop',
-  error: 'error'
+  error: 'error',
+  update: 'updates'
 };
 
 const PROVIDER_LABELS = {
@@ -15,6 +16,8 @@ const PROVIDER_LABELS = {
   cursor: 'Cursor',
   codex: 'Codex',
   gemini: 'Gemini',
+  qwen: 'Qwen Code',
+  opencode: 'OpenCode',
   system: 'System'
 };
 
@@ -121,7 +124,13 @@ function buildPushBody(event) {
     'run.stopped': event.meta?.stopReason || 'Run Stopped: The run has stopped',
     'run.failed': event.meta?.error ? `Run Failed: ${event.meta.error}` : 'Run Failed: The run encountered an error',
     'agent.notification': event.meta?.message ? String(event.meta.message) : 'You have a new notification',
-    'push.enabled': 'Push notifications are now enabled!'
+    'push.enabled': 'Push notifications are now enabled!',
+    'app.update.available': event.meta?.latestVersion
+      ? `Pixcode ${event.meta.latestVersion} is available`
+      : 'A Pixcode update is available',
+    'cli.update.available': event.meta?.latestVersion
+      ? `CLI update available: ${event.meta.latestVersion}`
+      : 'A CLI update is available'
   };
   const providerLabel = PROVIDER_LABELS[event.provider] || 'Assistant';
   const sessionName = resolveSessionName(event);

package/server/services/provider-cli-versions.js

@@ -0,0 +1,149 @@
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+
+const ONE_DAY_MS = 24 * 60 * 60 * 1000;
+const cache = new Map();
+const inflight = new Map();
+const execFileAsync = promisify(execFile);
+
+const providerConfigs = {
+  claude: {
+    command: () => process.env.CLAUDE_CLI_PATH || 'claude',
+    args: ['--version'],
+    packageName: '@anthropic-ai/claude-code',
+  },
+  cursor: {
+    command: () => process.env.CURSOR_CLI_PATH || 'cursor-agent',
+    args: ['--version'],
+    packageName: null,
+  },
+  codex: {
+    command: () => process.env.CODEX_CLI_PATH || 'codex',
+    args: ['--version'],
+    packageName: '@openai/codex',
+  },
+  gemini: {
+    command: () => process.env.GEMINI_CLI_PATH || 'gemini',
+    args: ['--version'],
+    packageName: '@google/gemini-cli',
+  },
+  qwen: {
+    command: () => process.env.QWEN_CLI_PATH || 'qwen',
+    args: ['--version'],
+    packageName: '@qwen-code/qwen-code',
+  },
+  opencode: {
+    command: () => process.env.OPENCODE_CLI_PATH || 'opencode',
+    args: ['--version'],
+    packageName: 'opencode-ai',
+  },
+};
+
+function normalizeVersion(value) {
+  const match = String(value || '').match(/\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?/);
+  return match?.[0] || null;
+}
+
+function compareVersions(left, right) {
+  const a = String(left || '0.0.0').replace(/^v/, '').split(/[.+-]/).slice(0, 3).map(Number);
+  const b = String(right || '0.0.0').replace(/^v/, '').split(/[.+-]/).slice(0, 3).map(Number);
+  for (let index = 0; index < Math.max(a.length, b.length); index += 1) {
+    const av = Number.isFinite(a[index]) ? a[index] : 0;
+    const bv = Number.isFinite(b[index]) ? b[index] : 0;
+    if (av !== bv) return av - bv;
+  }
+  return 0;
+}
+
+async function readInstalledVersion(config) {
+  try {
+    const result = await execFileAsync(config.command(), config.args, {
+      encoding: 'utf8',
+      timeout: 5000,
+      windowsHide: true,
+      maxBuffer: 64 * 1024,
+    });
+    return normalizeVersion(`${result.stdout || ''}\n${result.stderr || ''}`);
+  } catch {
+    return null;
+  }
+}
+
+async function readLatestVersion(packageName) {
+  if (!packageName) return null;
+  let result;
+  try {
+    result = await execFileAsync('npm', ['view', packageName, 'version', '--json'], {
+      encoding: 'utf8',
+      timeout: 7000,
+      windowsHide: true,
+      maxBuffer: 64 * 1024,
+    });
+  } catch {
+    return null;
+  }
+
+  try {
+    const parsed = JSON.parse(result.stdout);
+    return normalizeVersion(parsed);
+  } catch {
+    return normalizeVersion(result.stdout);
+  }
+}
+
+function getSkipReason(config, installedVersion, latestVersion) {
+  if (!config.packageName) return 'external_installer';
+  if (!installedVersion) return 'installed_version_unavailable';
+  if (!latestVersion) return 'latest_version_unavailable';
+  return null;
+}
+
+async function resolveProviderCliVersionStatus(provider, config, now) {
+  const installedVersion = await readInstalledVersion(config);
+  const latestVersion = await readLatestVersion(config.packageName);
+  const updateAvailable = Boolean(
+    installedVersion
+    && latestVersion
+    && compareVersions(latestVersion, installedVersion) > 0,
+  );
+
+  const payload = {
+    checkedAt: new Date(now).toISOString(),
+    installedVersion,
+    latestVersion,
+    updateAvailable,
+    versionCheckSkipped: getSkipReason(config, installedVersion, latestVersion),
+  };
+  cache.set(provider, { checkedAtMs: now, payload });
+  return payload;
+}
+
+export async function getProviderCliVersionStatus(provider, { installed = true, forceRefresh = false } = {}) {
+  const config = providerConfigs[provider];
+  if (!config || !installed) {
+    return {
+      checkedAt: new Date().toISOString(),
+      installedVersion: null,
+      latestVersion: null,
+      updateAvailable: false,
+      versionCheckSkipped: !config ? 'unsupported_provider' : 'not_installed',
+    };
+  }
+
+  const now = Date.now();
+  const cached = cache.get(provider);
+  if (!forceRefresh && cached && now - cached.checkedAtMs < ONE_DAY_MS) {
+    return { ...cached.payload, fromCache: true };
+  }
+
+  const inflightKey = provider;
+  if (!forceRefresh && inflight.has(inflightKey)) {
+    return inflight.get(inflightKey);
+  }
+
+  const promise = resolveProviderCliVersionStatus(provider, config, now).finally(() => {
+    inflight.delete(inflightKey);
+  });
+  inflight.set(inflightKey, promise);
+  return promise;
+}