@pixelbyte-software/pixcode 1.40.6 → 1.40.8

package/scripts/smoke/orchestration-model-sync.mjs

@@ -0,0 +1,30 @@
+#!/usr/bin/env node
+
+import assert from 'node:assert/strict';
+import { readFileSync } from 'node:fs';
+
+const page = readFileSync('src/components/orchestration/OrchestrationPage.tsx', 'utf8');
+const runner = readFileSync('server/modules/orchestration/workflows/workflow-runner.ts', 'utf8');
+
+assert.ok(
+  page.includes("from '../../hooks/useProviderModels'") || page.includes('from "@/hooks/useProviderModels"'),
+  'Orchestration page should use the same live provider model catalog hook as chat.',
+);
+
+assert.ok(
+  page.includes('providerModelCatalogs') && page.includes('sanitizeAgentModel'),
+  'Orchestration agents should sanitize stale selected models against the live catalog before starting runs.',
+);
+
+assert.ok(
+  runner.includes('resolveWorkflowModel') && runner.includes('modelCatalogsByProvider'),
+  'Workflow runner should validate provider models server-side before submitting A2A tasks.',
+);
+
+assert.ok(
+  runner.includes('Original user request')
+    && runner.indexOf('Original user request') < runner.lastIndexOf('workspaceContextPrompt(workspaceTarget)'),
+  'Workflow runner should place a labeled original user request before workspace context so agents do not answer the context header.',
+);
+
+console.log('orchestration model sync smoke passed');

package/scripts/smoke/provider-models-opencode-live.mjs

@@ -0,0 +1,66 @@
+#!/usr/bin/env node
+
+import assert from 'node:assert/strict';
+import { mkdtemp } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+
+const tempHome = await mkdtemp(path.join(os.tmpdir(), 'pixcode-provider-models-'));
+process.env.HOME = tempHome;
+process.env.OPENCODE_MODELS_URL = 'https://models.dev/test-api.json';
+
+const calls = [];
+globalThis.fetch = async (url) => {
+  calls.push(String(url));
+  return {
+    ok: true,
+    status: 200,
+    async json() {
+      return {
+        opencode: {
+          name: 'OpenCode Zen',
+          models: {
+            'big-pickle': {
+              name: 'Big Pickle',
+              cost: { input: 0, output: 0 },
+              limit: { context: 128000 },
+            },
+            'fresh-free': {
+              name: 'Fresh Free',
+              cost: { input: 0, output: 0 },
+              limit: { context: 64000 },
+            },
+          },
+        },
+      };
+    },
+  };
+};
+
+const { getProviderModels } = await import('../../server/services/provider-models.js');
+
+const staleStatic = [
+  { value: 'opencode/hy3-preview-free', label: 'Stale Hy3 Preview' },
+  { value: 'opencode/ling-2.6-flash-free', label: 'Stale Ling 2.6 Flash' },
+];
+
+const refreshed = await getProviderModels('opencode', {
+  forceRefresh: true,
+  staticList: staleStatic,
+});
+const refreshedValues = refreshed.models.map((model) => model.value);
+assert.equal(calls.length, 1, 'force refresh should fetch the OpenCode live catalog once');
+assert.ok(refreshedValues.includes('opencode/fresh-free'), 'live OpenCode models should be returned');
+assert.ok(!refreshedValues.includes('opencode/hy3-preview-free'), 'stale static OpenCode models must not be merged into a successful live catalog');
+assert.ok(!refreshedValues.includes('opencode/ling-2.6-flash-free'), 'stale static OpenCode models must not survive a successful live refresh');
+
+const cached = await getProviderModels('opencode', {
+  staticList: staleStatic,
+});
+const cachedValues = cached.models.map((model) => model.value);
+assert.equal(calls.length, 1, 'fresh cache should be used without another network request');
+assert.ok(cachedValues.includes('opencode/fresh-free'), 'cached live OpenCode models should be returned');
+assert.ok(!cachedValues.includes('opencode/hy3-preview-free'), 'cached live OpenCode catalog must stay free of stale static models');
+assert.ok(!cachedValues.includes('opencode/ling-2.6-flash-free'), 'cached live OpenCode catalog must stay free of stale static models');
+
+console.log('provider OpenCode live model catalog smoke passed');

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

@@ -13,6 +13,17 @@ import {
   workspaceTargetMetadata,
 } from '@/modules/orchestration/workflows/workspace-target.js';
 import { workflowStore } from '@/modules/orchestration/workflows/workflow-store.js';
+// @ts-ignore — plain-JS service
+import { getProviderModels } from '@/services/provider-models.js';
+
+import {
+  CLAUDE_MODELS,
+  CODEX_MODELS,
+  CURSOR_MODELS,
+  GEMINI_MODELS,
+  OPENCODE_MODELS,
+  QWEN_MODELS,
+} from '../../../../shared/modelConstants.js';
 
 const TERMINAL = new Set(['completed', 'failed', 'canceled']);
 const SKIPPED = 'skipped';
@@ -106,6 +117,34 @@ type AgentAssignment = {
 
 type KnownAgentRole = typeof KNOWN_AGENT_ROLES[number];
 type AgentRole = string;
+type ProviderId = 'claude' | 'cursor' | 'codex' | 'gemini' | 'qwen' | 'opencode';
+type ProviderModel = {
+  value: string;
+  label?: string;
+  source?: 'static' | 'api';
+  free?: boolean;
+};
+
+const adapterProviderMap: Record<string, ProviderId | undefined> = {
+  'claude-code': 'claude',
+  cursor: 'cursor',
+  codex: 'codex',
+  gemini: 'gemini',
+  qwen: 'qwen',
+  opencode: 'opencode',
+};
+
+const modelCatalogsByProvider: Record<ProviderId, {
+  staticList: ProviderModel[];
+  defaultModel?: string;
+}> = {
+  claude: { staticList: CLAUDE_MODELS.OPTIONS, defaultModel: CLAUDE_MODELS.DEFAULT },
+  cursor: { staticList: CURSOR_MODELS.OPTIONS, defaultModel: CURSOR_MODELS.DEFAULT },
+  codex: { staticList: CODEX_MODELS.OPTIONS, defaultModel: CODEX_MODELS.DEFAULT },
+  gemini: { staticList: GEMINI_MODELS.OPTIONS, defaultModel: GEMINI_MODELS.DEFAULT },
+  qwen: { staticList: QWEN_MODELS.OPTIONS, defaultModel: QWEN_MODELS.DEFAULT },
+  opencode: { staticList: OPENCODE_MODELS.OPTIONS, defaultModel: OPENCODE_MODELS.DEFAULT },
+};
 
 function readAgentRole(value: unknown): AgentRole | undefined {
   return typeof value === 'string' && value.trim() && value.trim() !== 'auto'
@@ -133,6 +172,44 @@ function readBoolean(value: unknown): boolean | undefined {
   return typeof value === 'boolean' ? value : undefined;
 }
 
+function modelValueSet(models: ProviderModel[]): Set<string> {
+  return new Set(models.map((model) => model.value).filter(Boolean));
+}
+
+function preferredFallbackModel(models: ProviderModel[], defaultModel?: string): string | undefined {
+  const values = modelValueSet(models);
+  if (defaultModel && values.has(defaultModel)) return defaultModel;
+  return models.find((model) => model.source === 'api' && model.free)?.value
+    ?? models.find((model) => model.source === 'api')?.value
+    ?? models.find((model) => model.free)?.value
+    ?? models[0]?.value
+    ?? defaultModel;
+}
+
+async function resolveWorkflowModel(adapterId: string, requestedModel?: string): Promise<string | undefined> {
+  const provider = adapterProviderMap[adapterId];
+  if (!provider) return requestedModel;
+
+  const catalog = modelCatalogsByProvider[provider];
+  if (!requestedModel) return catalog.defaultModel;
+
+  try {
+    const result = await getProviderModels(provider, {
+      staticList: catalog.staticList,
+    });
+    const models = Array.isArray(result?.models) ? result.models as ProviderModel[] : [];
+    if (modelValueSet(models).has(requestedModel)) {
+      return requestedModel;
+    }
+    return preferredFallbackModel(models, catalog.defaultModel) ?? requestedModel;
+  } catch {
+    const staticValues = modelValueSet(catalog.staticList);
+    return staticValues.has(requestedModel)
+      ? requestedModel
+      : preferredFallbackModel(catalog.staticList, catalog.defaultModel) ?? requestedModel;
+  }
+}
+
 function readIsolation(value: unknown): 'host' | 'worktree' | 'docker' | undefined {
   return value === 'host' || value === 'worktree' || value === 'docker' ? value : undefined;
 }
@@ -1408,15 +1485,42 @@ class WorkflowRunner {
 
     const inputContext = node.inputs.map((input) => outputs.get(input)).filter(Boolean).join('\n\n');
     const workspaceTarget = resolveWorkflowWorkspace(run.metadata);
-    const prompt = [workspaceContextPrompt(workspaceTarget), run.input, inputContext, node.prompt]
-      .filter(Boolean)
-      .join('\n\n');
+    const prompt = [
+      'Original user request (primary task; answer this directly even if the workspace is empty):',
+      run.input?.trim() || '(No original user request was provided.)',
+      inputContext
+        ? `Upstream workflow context from prior agents:\n${inputContext}`
+        : '',
+      `Current workflow step instructions:\n${node.prompt}`,
+      workspaceContextPrompt(workspaceTarget),
+    ].filter(Boolean).join('\n\n');
     const settings = getMetadataRecord(run.metadata, 'settings');
     const projectPath = workspaceTarget.projectPath;
     const isolation = readIsolation(settings.isolation) ?? node.isolation ?? 'host';
     const keepAfterCompletion = readBoolean(settings.keepWorkspace) ?? true;
     const baseRef = readString(settings.baseRef) ?? 'HEAD';
     const effectivePermissionMode = resolveNodePermissionMode(node, workspaceTarget);
+    const effectiveModel = await resolveWorkflowModel(node.adapterId, node.model);
+    if (effectiveModel !== node.model) {
+      nodeRun.model = effectiveModel;
+      const modelFallbackEvents = Array.isArray(run.metadata?.modelFallbackEvents)
+        ? run.metadata.modelFallbackEvents
+        : [];
+      run.metadata = {
+        ...run.metadata,
+        modelFallbackEvents: [
+          ...modelFallbackEvents,
+          {
+            nodeId: node.id,
+            adapterId: node.adapterId,
+            requestedModel: node.model,
+            effectiveModel,
+            changedAt: Date.now(),
+          },
+        ],
+      };
+      workflowStore.setRun(run);
+    }
     let body: { id?: string; error?: { message?: string } };
     try {
       const submit = await fetch(`${localA2ABaseUrl()}/tasks`, {
@@ -1436,7 +1540,7 @@ class WorkflowRunner {
             agentInstanceId: node.agentInstanceId,
             agentLabel: node.agentLabel,
             assignment: node.assignment,
-            model: node.model,
+            model: effectiveModel,
             permissionMode: effectivePermissionMode,
             toolsSettings: node.toolsSettings,
             projectPath,

package/server/services/live-view.js

@@ -208,6 +208,120 @@ function buildManagedPackageCommand(command, runtimeStatus) {
   };
 }
 
+function packageBinCandidates(binName) {
+  return process.platform === 'win32'
+    ? [binName, `${binName}.cmd`, `${binName}.ps1`, `${binName}.exe`]
+    : [binName];
+}
+
+function expectedPackageBin(command) {
+  if (command.framework === 'Vite' || command.id === 'npm-dev-vite') return 'vite';
+  if (command.framework === 'Next.js' || command.id === 'npm-dev-next') return 'next';
+  if (command.framework === 'Nuxt' || command.id === 'npm-dev-nuxt') return 'nuxt';
+  if (command.framework === 'Astro' || command.id === 'npm-dev-astro') return 'astro';
+  return null;
+}
+
+async function packageDependenciesReady(projectPath, command) {
+  if (!command?.scriptName && !command?.packageManager) return true;
+  if (!(await dirExists(path.join(projectPath, 'node_modules')))) return false;
+
+  const binName = expectedPackageBin(command);
+  if (!binName) return true;
+
+  const binDir = path.join(projectPath, 'node_modules', '.bin');
+  for (const candidate of packageBinCandidates(binName)) {
+    if (await fileExists(path.join(binDir, candidate))) return true;
+  }
+  return false;
+}
+
+function packageInstallInvocation(command) {
+  if (!command || command.packageManager !== 'npm') return null;
+
+  if (
+    command.managedRuntime?.id === 'npm'
+    && command.args?.[0]
+    && String(command.args[0]).endsWith('npm-cli.js')
+  ) {
+    return {
+      command: command.command,
+      args: [command.args[0], 'install', '--no-audit', '--no-fund'],
+      displayCommand: 'npm install --no-audit --no-fund',
+    };
+  }
+
+  if (command.command === 'npm' || path.basename(command.command || '').startsWith('npm')) {
+    return {
+      command: command.command,
+      args: ['install', '--no-audit', '--no-fund'],
+      displayCommand: 'npm install --no-audit --no-fund',
+    };
+  }
+
+  return null;
+}
+
+function runPrepProcess(command, args, options = {}) {
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    const child = spawn(command, args, {
+      cwd: options.cwd,
+      env: options.env,
+      shell: shouldUseShell({ command }),
+      stdio: ['ignore', 'pipe', 'pipe'],
+      windowsHide: true,
+    });
+    const timeoutMs = Number.parseInt(process.env.PIXCODE_LIVE_VIEW_INSTALL_TIMEOUT_MS || '', 10) || 300000;
+    const finish = (callback, value) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      callback(value);
+    };
+    const timer = setTimeout(() => {
+      try {
+        child.kill();
+      } catch {
+        // Process may already be gone.
+      }
+      finish(reject, new Error(`Dependency install timed out after ${Math.round(timeoutMs / 1000)}s.`));
+    }, timeoutMs);
+
+    child.stdout.on('data', (chunk) => {
+      chunk.toString().split(/\r?\n/).forEach((line) => options.onLog?.(line));
+    });
+    child.stderr.on('data', (chunk) => {
+      chunk.toString().split(/\r?\n/).forEach((line) => options.onLog?.(line));
+    });
+    child.on('error', (error) => finish(reject, error));
+    child.on('exit', (code, signal) => {
+      if (code === 0) {
+        finish(resolve);
+        return;
+      }
+      finish(reject, new Error(`Dependency install exited with ${signal || `code ${code}`}.`));
+    });
+  });
+}
+
+export async function preparePackageDependencies(projectPath, command, env = process.env, onLog = () => {}) {
+  if (!command || command.packageManager !== 'npm') return false;
+  if (await packageDependenciesReady(projectPath, command)) return false;
+
+  const install = packageInstallInvocation(command);
+  if (!install) return false;
+
+  onLog(`Installing project dependencies: ${install.displayCommand}`);
+  await runPrepProcess(install.command, install.args, {
+    cwd: projectPath,
+    env,
+    onLog,
+  });
+  onLog('Project dependencies are ready.');
+  return true;
+}
+
 function buildManagedPhpCommand(runtimeStatus) {
   const executable = runtimeStatus?.executablePath || 'frankenphp';
   return {
@@ -718,6 +832,20 @@ export async function startLiveView(projectName, projectPath, options = {}) {
     BROWSER: 'none',
     NEXT_TELEMETRY_DISABLED: '1',
   };
+
+  sessionsByProject.set(projectName, session);
+  sessionsByShareId.set(shareId, session);
+
+  try {
+    await preparePackageDependencies(projectPath, command, env, (line) => appendLog(session, line));
+  } catch (error) {
+    session.status = 'error';
+    session.stoppedAt = new Date().toISOString();
+    session.error = error instanceof Error ? error.message : String(error);
+    appendLog(session, session.error);
+    return publicSession(session);
+  }
+
   const child = spawn(command.command, command.args, {
     cwd: projectPath,
     env,
@@ -726,8 +854,6 @@ export async function startLiveView(projectName, projectPath, options = {}) {
   });
 
   session.child = child;
-  sessionsByProject.set(projectName, session);
-  sessionsByShareId.set(shareId, session);
 
   child.stdout.on('data', (chunk) => {
     chunk.toString().split(/\r?\n/).forEach((line) => appendLog(session, line));

package/server/services/managed-runtimes.js

@@ -121,21 +121,39 @@ async function downloadFile(url, targetFile, env = process.env) {
 function runProcess(command, args, options = {}) {
   return new Promise((resolve, reject) => {
     let stderr = '';
+    let settled = false;
+    const { timeoutMs, ...spawnOptions } = options;
     const child = spawn(command, args, {
-      ...options,
+      ...spawnOptions,
       stdio: ['ignore', 'ignore', 'pipe'],
       windowsHide: true,
     });
+    const finish = (callback, value) => {
+      if (settled) return;
+      settled = true;
+      if (timer) clearTimeout(timer);
+      callback(value);
+    };
+    const timer = timeoutMs
+      ? setTimeout(() => {
+        try {
+          child.kill();
+        } catch {
+          // Process may have exited between timeout scheduling and kill.
+        }
+        finish(reject, new Error(`${command} timed out after ${timeoutMs}ms`));
+      }, timeoutMs)
+      : null;
     child.stderr.on('data', (chunk) => {
       stderr += chunk.toString();
     });
-    child.on('error', reject);
+    child.on('error', (error) => finish(reject, error));
     child.on('close', (code) => {
       if (code === 0) {
-        resolve();
+        finish(resolve);
         return;
       }
-      reject(new Error(`${command} exited with code ${code}${stderr ? `: ${stderr.trim()}` : ''}`));
+      finish(reject, new Error(`${command} exited with code ${code}${stderr ? `: ${stderr.trim()}` : ''}`));
     });
   });
 }
@@ -200,6 +218,27 @@ async function findRuntimeExecutable(searchRoot, binaryName) {
   return null;
 }
 
+async function copyRuntimeWithSidecars(executablePath, currentDir) {
+  const executableDir = path.dirname(executablePath);
+  await fs.rm(currentDir, { recursive: true, force: true });
+  await fs.mkdir(currentDir, { recursive: true });
+  await fs.cp(executableDir, currentDir, { recursive: true, force: true });
+  return path.join(currentDir, path.basename(executablePath));
+}
+
+async function validateManagedRuntimeExecutable(id, executablePath, env = process.env) {
+  if (id !== 'frankenphp') return true;
+  try {
+    await runProcess(executablePath, ['version'], {
+      env,
+      timeoutMs: 5000,
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
 async function installFrankenPhp(env = process.env) {
   const releaseApiUrl = env.PIXCODE_FRANKENPHP_RELEASE_API
     || 'https://api.github.com/repos/php/frankenphp/releases/latest';
@@ -245,12 +284,7 @@ async function installFrankenPhp(env = process.env) {
     await fs.chmod(executablePath, 0o755).catch(() => undefined);
   }
 
-  await fs.rm(currentDir, { recursive: true, force: true });
-  await fs.mkdir(currentDir, { recursive: true });
-
-  const finalName = process.platform === 'win32' ? 'frankenphp.exe' : 'frankenphp';
-  const finalExecutable = path.join(currentDir, finalName);
-  await fs.copyFile(executablePath, finalExecutable);
+  const finalExecutable = await copyRuntimeWithSidecars(executablePath, currentDir);
   if (process.platform !== 'win32') {
     await fs.chmod(finalExecutable, 0o755).catch(() => undefined);
   }
@@ -379,6 +413,18 @@ export async function getManagedRuntimeStatus(id, options = {}) {
 
   const manifest = await readManifest(id, env);
   if (manifest) {
+    const valid = await validateManagedRuntimeExecutable(id, manifest.executablePath, env);
+    if (!valid) {
+      return {
+        id,
+        label: 'Pixcode PHP runtime',
+        provider: 'FrankenPHP',
+        status: 'missing',
+        installable: true,
+        reason: 'The existing Pixcode PHP runtime is incomplete or cannot start. Pixcode will reinstall it automatically.',
+      };
+    }
+
     return {
       id,
       label: manifest.label || 'Pixcode PHP runtime',

package/server/services/provider-models.js

@@ -86,6 +86,20 @@ function mergeCatalogs(primary, secondary) {
     return Array.from(seen.values());
 }
 
+function mergeProviderCatalogs(provider, primary, staticCatalog) {
+    const normalizedPrimary = normalizeList(primary);
+
+    // OpenCode Zen free models rotate often. When models.dev succeeds, treat
+    // that live catalog as authoritative; otherwise stale static freebies can
+    // leak back into the UI and fail later with ProviderModelNotFoundError.
+    if (provider === 'opencode') {
+        const liveModels = normalizedPrimary.filter((item) => item.source === 'api');
+        if (liveModels.length > 0) return liveModels;
+    }
+
+    return mergeCatalogs(normalizedPrimary, staticCatalog);
+}
+
 // ---------------- Per-provider live discovery ----------------
 
 async function discoverAnthropic(apiKey, baseUrl) {
@@ -287,8 +301,9 @@ export async function getProviderModels(provider, opts = {}) {
         : false;
 
     if (!forceRefresh && cacheFresh && Array.isArray(cached?.models)) {
+        const merged = mergeProviderCatalogs(provider, cached.models, staticCatalog);
         return {
-            models: mergeCatalogs(normalizeList(cached.models), staticCatalog),
+            models: merged,
             fetchedAt: cached.fetchedAt,
             error: cached.error,
             fromCache: true,
@@ -305,7 +320,7 @@ export async function getProviderModels(provider, opts = {}) {
         } catch (err) {
             error = err?.message || String(err);
         }
-        const merged = mergeCatalogs(normalizeList(liveModels), staticCatalog);
+        const merged = mergeProviderCatalogs(provider, liveModels, staticCatalog);
         const entry = { models: merged, error };
         await saveCacheEntry(provider, entry).catch(() => { /* non-fatal */ });
         return { models: merged, fetchedAt: new Date().toISOString(), error, fromCache: false };
@@ -367,7 +382,7 @@ export async function getProviderModels(provider, opts = {}) {
         }
     }
 
-    const merged = mergeCatalogs(normalizeList(liveModels), staticCatalog);
+    const merged = mergeProviderCatalogs(provider, liveModels, staticCatalog);
     const entry = { models: merged, error };
     await saveCacheEntry(provider, entry).catch(() => { /* non-fatal */ });
     return { models: merged, fetchedAt: new Date().toISOString(), error, fromCache: false };

package/shared/modelConstants.js

@@ -110,11 +110,10 @@ export const QWEN_MODELS = {
 export const OPENCODE_MODELS = {
   OPTIONS: [
     // OpenCode Zen — free tier (no charge, may rate-limit). The "limited
-    // time" Zen freebies rotate, so this is the safest small set.
+    // time" Zen freebies rotate, so keep this fallback conservative and let
+    // the live models.dev catalog populate the full current list.
     { value: "opencode/big-pickle", label: "OpenCode Zen · Big Pickle (Free)", free: true },
     { value: "opencode/minimax-m2.5-free", label: "OpenCode Zen · MiniMax M2.5 (Free)", free: true },
-    { value: "opencode/hy3-preview-free", label: "OpenCode Zen · Hy3 Preview (Free)", free: true },
-    { value: "opencode/ling-2.6-flash-free", label: "OpenCode Zen · Ling 2.6 Flash (Free)", free: true },
     { value: "opencode/nemotron-3-super-free", label: "OpenCode Zen · Nemotron 3 Super (Free)", free: true },
     { value: "opencode/gpt-5-nano", label: "OpenCode Zen · GPT-5 Nano (Free)", free: true },