@pixelbyte-software/pixcode 1.38.5 → 1.39.1

package/scripts/smoke/command-center-agent-writes.mjs

@@ -28,13 +28,26 @@ assert.ok(
   'Changed-files monitor should ingest the latest realtime agent message in addition to polling git/filesystem status.',
 );
 
+assert.ok(
+  changedFilesHook.includes("ChangedFilesTrackingMode = 'local' | 'git'")
+    && changedFilesHook.includes('mode: trackingMode')
+    && changedFilesHook.includes("trackingMode !== 'local'"),
+  'Changed-files monitor should support separate Local changes and Git changes modes.',
+);
+
 assert.ok(
   changedFilesHook.includes('mergeChangedFiles'),
   'Changed-files monitor should merge direct agent writes with polled git/filesystem changes instead of replacing them.',
 );
 
 assert.ok(
-  mainContent.includes('useChangedFilesMonitor(selectedProject, changeAwareness, latestMessage)'),
+  changedFilesHook.includes("data.trackingMode === 'filesystem'")
+    && changedFilesHook.includes('mergeChangedFiles(polledChangedFilesRef.current, detectedChangedFiles)'),
+  'Filesystem tracking should keep detected files visible after the next empty poll instead of flashing for one interval.',
+);
+
+assert.ok(
+  mainContent.includes('useChangedFilesMonitor(selectedProject, changeAwareness, latestMessage, changeTrackingMode)'),
   'MainContent should pass latestMessage into the changed-files monitor.',
 );
 
@@ -43,6 +56,19 @@ assert.ok(
   'Clicking a changed file should open the editor with diff context, not only focus the Files panel.',
 );
 
+assert.ok(
+  mainContent.includes('/api/git/file-with-diff') && mainContent.includes('old_string') && mainContent.includes('new_string'),
+  'Clicking a changed file without realtime diff metadata should hydrate editor diff context before focusing the changed chunk.',
+);
+
+assert.ok(
+  rail.includes('trackingMode: ChangedFilesTrackingMode')
+    && rail.includes('Local changes')
+    && rail.includes('Git changes')
+    && rail.includes('onTrackingModeChange'),
+  'Command Center rail should expose a visible switch between Local changes and Git changes.',
+);
+
 assert.ok(
   rail.includes('onOpenFile: (file: ChangedFileEntry) => void') && rail.includes('onClick={() => onOpenFile(file)}'),
   'ChangedFilesActivityRail should pass the full changed-file entry, including diffInfo, to the open handler.',

package/scripts/smoke/orchestration-mobile-scroll.mjs

@@ -0,0 +1,29 @@
+#!/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 runPanel = readFileSync('src/components/orchestration/workflows/WorkflowRunPanel.tsx', 'utf8');
+
+assert.ok(
+  page.includes('overflow-y-auto lg:overflow-hidden'),
+  'Orchestration mobile layout should allow page-level vertical scrolling before desktop split mode.',
+);
+
+assert.ok(
+  /<aside[^>]+className="[^"]*overflow-visible[^"]*lg:overflow-auto/.test(page),
+  'Orchestration setup pane should not trap scrolling on mobile.',
+);
+
+assert.ok(
+  /<section[^>]+className="[^"]*overflow-visible[^"]*lg:overflow-hidden/.test(page),
+  'Orchestration run section should stay reachable in mobile document flow.',
+);
+
+assert.ok(
+  /className="[^"]*overflow-visible[^"]*xl:overflow-auto/.test(runPanel),
+  'Workflow run panel should avoid nested scroll traps before its desktop two-column layout.',
+);
+
+console.log('orchestration mobile scroll smoke passed');

package/scripts/smoke/orchestration-runtime-guards.mjs

@@ -0,0 +1,48 @@
+#!/usr/bin/env node
+
+import assert from 'node:assert/strict';
+import { readFileSync } from 'node:fs';
+
+const a2aRoutes = readFileSync('server/modules/orchestration/a2a/routes.ts', 'utf8');
+const hostWorkspace = readFileSync('server/modules/orchestration/workspace/workspace-manager.ts', 'utf8');
+const worktreeWorkspace = readFileSync('server/modules/orchestration/workspace/worktree-workspace.ts', 'utf8');
+const dockerWorkspace = readFileSync('server/modules/orchestration/workspace/docker-workspace.ts', 'utf8');
+const opencodeCli = readFileSync('server/opencode-cli.js', 'utf8');
+const geminiCli = readFileSync('server/gemini-cli.js', 'utf8');
+const qwenCli = readFileSync('server/qwen-code-cli.js', 'utf8');
+
+assert.ok(
+  hostWorkspace.includes("rev-parse', '--is-inside-work-tree")
+    && hostWorkspace.includes("return '';"),
+  'Host orchestration workspace diff should skip git diff when the project is not a git work tree.',
+);
+
+for (const [name, source] of [
+  ['worktree', worktreeWorkspace],
+  ['docker', dockerWorkspace],
+]) {
+  assert.ok(
+    source.includes('not a git repository|usage: git diff --no-index') && source.includes("return /not a git repository"),
+    `${name} orchestration workspace diff should suppress noisy git --no-index usage output.`,
+  );
+}
+
+assert.ok(
+  a2aRoutes.includes('if (diff.trim())') && a2aRoutes.includes("type: 'file-diff'"),
+  'A2A finalization should not publish empty or noisy workspace diff artifacts.',
+);
+
+for (const [name, source] of [
+  ['opencode', opencodeCli],
+  ['gemini', geminiCli],
+  ['qwen', qwenCli],
+]) {
+  assert.ok(
+    source.includes('DEFAULT_CLI_IDLE_TIMEOUT_MS = 600000')
+      && source.includes('PIXCODE_CLI_IDLE_TIMEOUT_MS')
+      && source.includes('if (timeoutMs === 0) return;'),
+    `${name} CLI runtime should use a longer configurable idle timeout.`,
+  );
+}
+
+console.log('orchestration runtime guards smoke passed');

package/scripts/smoke/taskmaster-config.mjs

@@ -0,0 +1,59 @@
+#!/usr/bin/env node
+
+import assert from 'node:assert/strict';
+import { readFileSync } from 'node:fs';
+
+const taskmasterRoutes = readFileSync('server/routes/taskmaster.js', 'utf8');
+const taskmasterConfig = readFileSync('server/services/taskmaster-config.js', 'utf8');
+const tasksSettingsContext = readFileSync('src/contexts/TasksSettingsContext.jsx', 'utf8');
+const tasksSettingsTab = readFileSync('src/components/settings/view/tabs/tasks-settings/TasksSettingsTab.tsx', 'utf8');
+const mainContentState = readFileSync('src/components/main-content/view/subcomponents/MainContentStateView.tsx', 'utf8');
+
+assert.ok(
+  taskmasterConfig.includes('TASKMASTER_CONFIG_FIELDS') && taskmasterConfig.includes('ANTHROPIC_API_KEY'),
+  'TaskMaster should have a dedicated config store for provider environment variables.',
+);
+
+assert.ok(
+  taskmasterConfig.includes('OPENAI_BASE_URL') && taskmasterConfig.includes('AZURE_OPENAI_ENDPOINT'),
+  'TaskMaster config should support API URL / endpoint fields, not only keys.',
+);
+
+assert.ok(
+  taskmasterConfig.includes('openaiCompatibleApiKey')
+    && taskmasterConfig.includes('OPENAI_COMPATIBLE_BASE_URL')
+    && taskmasterConfig.includes('CUSTOM_OPENAI_API_KEY')
+    && taskmasterConfig.includes('buildTaskMasterConfigEnvValues'),
+  'TaskMaster config should support custom OpenAI-compatible API keys, API URLs, model values, and shared env resolution.',
+);
+
+assert.ok(
+  taskmasterRoutes.includes("router.get('/config'") && taskmasterRoutes.includes("router.put('/config'"),
+  'TaskMaster routes should expose authenticated config read/write endpoints.',
+);
+
+assert.ok(
+  taskmasterRoutes.includes('buildTaskMasterCliEnv') && taskmasterRoutes.includes('task-master-ai'),
+  'TaskMaster CLI execution should receive saved env config and detect both task-master and task-master-ai binaries.',
+);
+
+assert.ok(
+  tasksSettingsContext.includes('refreshTaskMasterInstallation'),
+  'Task settings context should expose a manual TaskMaster installation refresh action.',
+);
+
+assert.ok(
+  tasksSettingsTab.includes('/api/taskmaster/config')
+    && tasksSettingsTab.includes('ANTHROPIC_API_KEY')
+    && tasksSettingsTab.includes('OPENAI_BASE_URL')
+    && tasksSettingsTab.includes('Custom OpenAI-compatible')
+    && tasksSettingsTab.includes('OPENAI_COMPATIBLE_MODEL'),
+  'Task settings tab should let users save TaskMaster API keys, API URLs, and custom OpenAI-compatible provider settings.',
+);
+
+assert.ok(
+  mainContentState.includes('pixcode:create-project') && mainContentState.includes('mainContent.landing.taskSystem'),
+  'Landing Task system card should be actionable instead of a static locked-looking panel.',
+);
+
+console.log('taskmaster config smoke passed');

package/server/gemini-cli.js

@@ -15,6 +15,12 @@ import { createNormalizedMessage } from './shared/utils.js';
 // Use cross-spawn on Windows for correct .cmd resolution (same pattern as cursor-cli.js)
 const spawnFunction = process.platform === 'win32' ? crossSpawn : spawn;
 let activeGeminiProcesses = new Map(); // Track active processes by session ID
+const DEFAULT_CLI_IDLE_TIMEOUT_MS = 600000;
+
+function readCliIdleTimeoutMs() {
+    const configured = Number.parseInt(process.env.PIXCODE_CLI_IDLE_TIMEOUT_MS || '', 10);
+    return Number.isFinite(configured) && configured >= 0 ? configured : DEFAULT_CLI_IDLE_TIMEOUT_MS;
+}
 
 /**
  * Auto-create `~/.gemini/settings.json` when the user has signed in via OAuth
@@ -287,11 +293,12 @@ async function spawnGemini(command, options = {}, ws) {
         geminiProcess.stdin.end();
 
         // Add timeout handler
-        const timeoutMs = 120000; // 120 seconds for slower models
+        const timeoutMs = readCliIdleTimeoutMs();
         let timeout;
 
         const startTimeout = () => {
             if (timeout) clearTimeout(timeout);
+            if (timeoutMs === 0) return;
             timeout = setTimeout(() => {
                 const socketSessionId = typeof ws.getSessionId === 'function' ? ws.getSessionId() : (capturedSessionId || sessionId || processKey);
                 terminalFailureReason = `Gemini CLI timeout - no response received for ${timeoutMs / 1000} seconds`;
@@ -400,6 +407,7 @@ async function spawnGemini(command, options = {}, ws) {
         // Handle stderr
         geminiProcess.stderr.on('data', (data) => {
             const errorMsg = data.toString();
+            startTimeout();
 
             // Filter out deprecation warnings and "Loaded cached credentials" message
             if (errorMsg.includes('[DEP0040]') ||

package/server/modules/orchestration/a2a/routes.ts

@@ -179,21 +179,23 @@ async function finalizeTerminalTask(task: Task): Promise<void> {
   try {
     if (workspace) {
       const diff = await workspace.diff();
-      a2aBus.publish({
-        kind: 'artifact',
-        taskId: task.id,
-        artifact: {
-          artifactId: newId('art'),
-          type: 'file-diff',
-          parts: [{ kind: 'text', text: diff }],
-          metadata: {
-            source: 'workspace-diff',
-            workspaceId: workspace.id,
-            workspaceKind: workspace.kind,
-            baseRef: workspace.baseRef,
+      if (diff.trim()) {
+        a2aBus.publish({
+          kind: 'artifact',
+          taskId: task.id,
+          artifact: {
+            artifactId: newId('art'),
+            type: 'file-diff',
+            parts: [{ kind: 'text', text: diff }],
+            metadata: {
+              source: 'workspace-diff',
+              workspaceId: workspace.id,
+              workspaceKind: workspace.kind,
+              baseRef: workspace.baseRef,
+            },
           },
-        },
-      });
+        });
+      }
 
       const keepAfterCompletion = task.metadata?.workspace &&
         typeof task.metadata.workspace === 'object' &&

package/server/modules/orchestration/workspace/docker-workspace.ts

@@ -125,7 +125,8 @@ export class DockerWorkspace implements WorkspaceHandle {
       return String(stdout);
     } catch (error) {
       const err = error as Error & { stderr?: string };
-      return String(err.stderr ?? err.message);
+      const output = String(err.stderr ?? err.message);
+      return /not a git repository|usage: git diff --no-index/i.test(output) ? '' : output;
     }
   }
 

package/server/modules/orchestration/workspace/workspace-manager.ts

@@ -56,6 +56,11 @@ class HostWorkspace implements WorkspaceHandle {
   }
 
   async diff(): Promise<string> {
+    const insideWorkTree = await this.exec('git', ['rev-parse', '--is-inside-work-tree']);
+    if (insideWorkTree.exitCode !== 0 || insideWorkTree.stdout.trim() !== 'true') {
+      return '';
+    }
+
     const result = await this.exec('git', ['diff', `${this.baseRef}...HEAD`]);
     return result.exitCode === 0 ? result.stdout : result.stderr || result.stdout;
   }

package/server/modules/orchestration/workspace/worktree-workspace.ts

@@ -109,7 +109,8 @@ export class WorktreeWorkspace implements WorkspaceHandle {
   async diff(): Promise<string> {
     const result = await run('git', ['diff', `${this.baseRef}...HEAD`], this.path);
     if (result.exitCode !== 0) {
-      return result.stderr || result.stdout;
+      const output = result.stderr || result.stdout;
+      return /not a git repository|usage: git diff --no-index/i.test(output) ? '' : output;
     }
     return result.stdout;
   }

package/server/opencode-cli.js

@@ -37,6 +37,12 @@ import { createNormalizedMessage } from './shared/utils.js';
 const spawnFunction = process.platform === 'win32' ? crossSpawn : spawn;
 
 const activeOpencodeProcesses = new Map();
+const DEFAULT_CLI_IDLE_TIMEOUT_MS = 600000;
+
+function readCliIdleTimeoutMs() {
+    const configured = Number.parseInt(process.env.PIXCODE_CLI_IDLE_TIMEOUT_MS || '', 10);
+    return Number.isFinite(configured) && configured >= 0 ? configured : DEFAULT_CLI_IDLE_TIMEOUT_MS;
+}
 
 function mapPermissionModeToArgs(permissionMode, skipPermissions) {
     // OpenCode's permission model is per-tool/per-pattern (see opencode.json
@@ -233,10 +239,11 @@ async function spawnOpencode(command, options = {}, ws) {
 
         opencodeProcess.stdin.end();
 
-        const timeoutMs = 120000;
+        const timeoutMs = readCliIdleTimeoutMs();
         let timeout;
         const startTimeout = () => {
             if (timeout) clearTimeout(timeout);
+            if (timeoutMs === 0) return;
             timeout = setTimeout(() => {
                 const socketSessionId = typeof ws.getSessionId === 'function' ? ws.getSessionId() : (capturedSessionId || sessionId || processKey);
                 terminalFailureReason = `OpenCode CLI timeout - no response received for ${timeoutMs / 1000} seconds`;
@@ -333,6 +340,7 @@ async function spawnOpencode(command, options = {}, ws) {
 
         opencodeProcess.stderr.on('data', (data) => {
             const rawMsg = data.toString();
+            startTimeout();
             // Suppress known cosmetic noise.
             if (rawMsg.includes('[DEP0040]') ||
                 rawMsg.includes('DeprecationWarning') ||

package/server/qwen-code-cli.js

@@ -26,6 +26,12 @@ import { createNormalizedMessage } from './shared/utils.js';
 const spawnFunction = process.platform === 'win32' ? crossSpawn : spawn;
 
 const activeQwenProcesses = new Map();
+const DEFAULT_CLI_IDLE_TIMEOUT_MS = 600000;
+
+function readCliIdleTimeoutMs() {
+    const configured = Number.parseInt(process.env.PIXCODE_CLI_IDLE_TIMEOUT_MS || '', 10);
+    return Number.isFinite(configured) && configured >= 0 ? configured : DEFAULT_CLI_IDLE_TIMEOUT_MS;
+}
 
 async function spawnQwen(command, options = {}, ws) {
     const { sessionId, projectPath, cwd, toolsSettings, permissionMode, images, sessionSummary } = options;
@@ -170,10 +176,11 @@ async function spawnQwen(command, options = {}, ws) {
 
         qwenProcess.stdin.end();
 
-        const timeoutMs = 120000;
+        const timeoutMs = readCliIdleTimeoutMs();
         let timeout;
         const startTimeout = () => {
             if (timeout) clearTimeout(timeout);
+            if (timeoutMs === 0) return;
             timeout = setTimeout(() => {
                 const socketSessionId = typeof ws.getSessionId === 'function' ? ws.getSessionId() : (capturedSessionId || sessionId || processKey);
                 terminalFailureReason = `Qwen Code CLI timeout - no response received for ${timeoutMs / 1000} seconds`;
@@ -267,6 +274,7 @@ async function spawnQwen(command, options = {}, ws) {
 
         qwenProcess.stderr.on('data', (data) => {
             const errorMsg = data.toString();
+            startTimeout();
             if (errorMsg.includes('[DEP0040]') ||
                 errorMsg.includes('DeprecationWarning') ||
                 errorMsg.includes('--trace-deprecation') ||

package/server/routes/git.js

@@ -436,6 +436,8 @@ async function resolveRepositoryFilePath(projectPath, filePath) {
 // Get git status for a project
 router.get('/status', async (req, res) => {
   const { project } = req.query;
+  const requestedTrackingMode = String(req.query.mode || req.query.trackingMode || '').toLowerCase();
+  const gitOnly = requestedTrackingMode === 'git';
 
   if (!project) {
     return res.status(400).json({ error: 'Project name is required' });
@@ -477,6 +479,8 @@ router.get('/status', async (req, res) => {
     });
 
     res.json({
+      isGitRepository: true,
+      trackingMode: 'git',
       branch,
       hasCommits,
       modified,
@@ -485,7 +489,7 @@ router.get('/status', async (req, res) => {
       untracked
     });
   } catch (error) {
-    if (projectPath && isNotGitRepositoryMessage(error.message)) {
+    if (projectPath && !gitOnly && isNotGitRepositoryMessage(error.message)) {
       try {
         res.json(await buildFilesystemStatus(projectPath));
         return;
@@ -496,6 +500,8 @@ router.get('/status', async (req, res) => {
 
     console.error('Git status error:', error);
     res.json({
+      isGitRepository: false,
+      trackingMode: gitOnly ? 'git' : undefined,
       error: error.message.includes('not a git repository') || error.message.includes('Project directory is not a git repository')
         ? error.message
         : 'Git operation failed',

package/server/routes/taskmaster.js

@@ -26,6 +26,11 @@ import {
     getInstallJob,
     snapshotDonePayload
 } from '../services/install-jobs.js';
+import {
+    buildTaskMasterEnv,
+    getTaskMasterConfigSummary,
+    saveTaskMasterConfig
+} from '../services/taskmaster-config.js';
 import { broadcastTaskMasterProjectUpdate, broadcastTaskMasterTasksUpdate } from '../utils/taskmaster-websocket.js';
 import { detectTaskMasterMCPServer } from '../utils/mcp-detector.js';
 
@@ -35,22 +40,42 @@ const router = express.Router();
  * Check if TaskMaster CLI is installed globally
  * @returns {Promise<Object>} Installation status result
  */
+async function buildTaskMasterCliEnv(baseEnv = process.env) {
+    return buildTaskMasterEnv(buildCliSpawnEnv(baseEnv));
+}
+
+function findTaskMasterExecutable(env) {
+    const taskMasterPath = findExecutableOnPath('task-master', env);
+    if (taskMasterPath) {
+        return { path: taskMasterPath, name: 'task-master' };
+    }
+
+    const legacyPath = findExecutableOnPath('task-master-ai', env);
+    if (legacyPath) {
+        return { path: legacyPath, name: 'task-master-ai' };
+    }
+
+    return null;
+}
+
 async function checkTaskMasterInstallation() {
+    const env = await buildTaskMasterCliEnv();
+
     return new Promise((resolve) => {
-        const env = buildCliSpawnEnv();
-        const taskMasterPath = findExecutableOnPath('task-master', env);
+        const executable = findTaskMasterExecutable(env);
 
-        if (!taskMasterPath) {
+        if (!executable) {
             resolve({
                 isInstalled: false,
                 installPath: null,
                 version: null,
+                binary: null,
                 reason: 'TaskMaster CLI not found in PATH'
             });
             return;
         }
 
-        const versionChild = crossSpawn(taskMasterPath, ['--version'], {
+        const versionChild = crossSpawn(executable.path, ['--version'], {
             stdio: ['ignore', 'pipe', 'pipe'],
             env,
             windowsHide: true,
@@ -65,7 +90,8 @@ async function checkTaskMasterInstallation() {
         versionChild.on('close', (versionCode) => {
             resolve({
                 isInstalled: true,
-                installPath: taskMasterPath,
+                installPath: executable.path,
+                binary: executable.name,
                 version: versionCode === 0 ? versionOutput.trim() : 'unknown',
                 reason: null
             });
@@ -74,7 +100,8 @@ async function checkTaskMasterInstallation() {
         versionChild.on('error', () => {
             resolve({
                 isInstalled: true,
-                installPath: taskMasterPath,
+                installPath: executable.path,
+                binary: executable.name,
                 version: 'unknown',
                 reason: null
             });
@@ -165,6 +192,46 @@ function buildTaskMasterQueueSummary(projectName, projectPath, tasks) {
 
 // API Routes
 
+/**
+ * GET /api/taskmaster/config
+ * Return redacted TaskMaster provider env configuration.
+ */
+router.get('/config', async (req, res) => {
+    try {
+        res.json({
+            success: true,
+            config: await getTaskMasterConfigSummary()
+        });
+    } catch (error) {
+        console.error('Error reading TaskMaster config:', error);
+        res.status(500).json({
+            success: false,
+            error: 'Failed to read TaskMaster configuration',
+            message: error.message
+        });
+    }
+});
+
+/**
+ * PUT /api/taskmaster/config
+ * Persist TaskMaster provider env configuration.
+ */
+router.put('/config', async (req, res) => {
+    try {
+        res.json({
+            success: true,
+            config: await saveTaskMasterConfig(req.body || {})
+        });
+    } catch (error) {
+        console.error('Error saving TaskMaster config:', error);
+        res.status(500).json({
+            success: false,
+            error: 'Failed to save TaskMaster configuration',
+            message: error.message
+        });
+    }
+});
+
 /**
  * GET /api/taskmaster/installation-status
  * Check if TaskMaster CLI is installed on the system
@@ -814,7 +881,8 @@ router.post('/init/:projectName', async (req, res) => {
         // Run taskmaster init command
         const initProcess = spawn('npx', ['task-master', 'init'], {
             cwd: projectPath,
-            stdio: ['pipe', 'pipe', 'pipe']
+            stdio: ['pipe', 'pipe', 'pipe'],
+            env: await buildTaskMasterCliEnv()
         });
 
         let stdout = '';
@@ -917,7 +985,8 @@ router.post('/add-task/:projectName', async (req, res) => {
         // Run task-master add-task command
         const addTaskProcess = spawn('npx', args, {
             cwd: projectPath,
-            stdio: ['pipe', 'pipe', 'pipe']
+            stdio: ['pipe', 'pipe', 'pipe'],
+            env: await buildTaskMasterCliEnv()
         });
 
         let stdout = '';
@@ -997,7 +1066,8 @@ router.put('/update-task/:projectName/:taskId', async (req, res) => {
         if (status && Object.keys(req.body).length === 1) {
             const setStatusProcess = spawn('npx', ['task-master-ai', 'set-status', `--id=${taskId}`, `--status=${status}`], {
                 cwd: projectPath,
-                stdio: ['pipe', 'pipe', 'pipe']
+                stdio: ['pipe', 'pipe', 'pipe'],
+                env: await buildTaskMasterCliEnv()
             });
 
             let stdout = '';
@@ -1049,7 +1119,8 @@ router.put('/update-task/:projectName/:taskId', async (req, res) => {
 
             const updateProcess = spawn('npx', ['task-master-ai', 'update-task', `--id=${taskId}`, `--prompt=${prompt}`], {
                 cwd: projectPath,
-                stdio: ['pipe', 'pipe', 'pipe']
+                stdio: ['pipe', 'pipe', 'pipe'],
+                env: await buildTaskMasterCliEnv()
             });
 
             let stdout = '';
@@ -1148,7 +1219,8 @@ router.post('/parse-prd/:projectName', async (req, res) => {
         // Run task-master parse-prd command
         const parsePRDProcess = spawn('npx', args, {
             cwd: projectPath,
-            stdio: ['pipe', 'pipe', 'pipe']
+            stdio: ['pipe', 'pipe', 'pipe'],
+            env: await buildTaskMasterCliEnv()
         });
 
         let stdout = '';