@pixelbyte-software/pixcode 1.38.2 → 1.38.4

package/server/routes/git.js

@@ -10,6 +10,150 @@ import { spawnCursor } from '../cursor-cli.js';
 
 const router = express.Router();
 const COMMIT_DIFF_CHARACTER_LIMIT = 500_000;
+const FILESYSTEM_SCAN_MAX_FILES = 5_000;
+const FILESYSTEM_SCAN_MAX_DEPTH = 10;
+const filesystemChangeSnapshots = new Map();
+const FILESYSTEM_SCAN_EXCLUDED_DIRS = new Set([
+  '.git',
+  '.hg',
+  '.svn',
+  'node_modules',
+  'dist',
+  'dist-server',
+  'build',
+  '.next',
+  '.nuxt',
+  '.svelte-kit',
+  'coverage',
+  '.turbo',
+  '.cache',
+  '.pixcode-dev',
+]);
+
+function isNotGitRepositoryMessage(message = '') {
+  return message.includes('Not a git repository')
+    || message.includes('not a git repository')
+    || message.includes('Project directory is not a git repository');
+}
+
+function shouldSkipFilesystemEntry(entryName) {
+  return FILESYSTEM_SCAN_EXCLUDED_DIRS.has(entryName)
+    || entryName.endsWith('.log')
+    || entryName === '.DS_Store';
+}
+
+function toProjectRelativePath(projectPath, filePath) {
+  return path.relative(projectPath, filePath).replace(/\\/g, '/');
+}
+
+async function collectFilesystemSnapshot(projectPath) {
+  const snapshot = new Map();
+  let limitReached = false;
+
+  async function walk(directoryPath, depth) {
+    if (limitReached || depth > FILESYSTEM_SCAN_MAX_DEPTH) {
+      return;
+    }
+
+    let entries = [];
+    try {
+      entries = await fs.readdir(directoryPath, { withFileTypes: true });
+    } catch {
+      return;
+    }
+
+    for (const entry of entries) {
+      if (limitReached || shouldSkipFilesystemEntry(entry.name)) {
+        continue;
+      }
+
+      const absolutePath = path.join(directoryPath, entry.name);
+
+      if (entry.isDirectory()) {
+        await walk(absolutePath, depth + 1);
+        continue;
+      }
+
+      if (!entry.isFile()) {
+        continue;
+      }
+
+      try {
+        const stat = await fs.stat(absolutePath);
+        snapshot.set(toProjectRelativePath(projectPath, absolutePath), {
+          mtimeMs: Math.round(stat.mtimeMs),
+          size: stat.size,
+        });
+      } catch {
+        continue;
+      }
+
+      if (snapshot.size >= FILESYSTEM_SCAN_MAX_FILES) {
+        limitReached = true;
+        break;
+      }
+    }
+  }
+
+  await walk(projectPath, 0);
+  return { snapshot, limitReached };
+}
+
+function diffFilesystemSnapshots(previousSnapshot, nextSnapshot) {
+  if (!previousSnapshot) {
+    return { modified: [], added: [], deleted: [] };
+  }
+
+  const modified = [];
+  const added = [];
+  const deleted = [];
+
+  for (const [filePath, nextMeta] of nextSnapshot.entries()) {
+    const previousMeta = previousSnapshot.get(filePath);
+    if (!previousMeta) {
+      added.push(filePath);
+      continue;
+    }
+
+    if (previousMeta.mtimeMs !== nextMeta.mtimeMs || previousMeta.size !== nextMeta.size) {
+      modified.push(filePath);
+    }
+  }
+
+  for (const filePath of previousSnapshot.keys()) {
+    if (!nextSnapshot.has(filePath)) {
+      deleted.push(filePath);
+    }
+  }
+
+  return {
+    modified: modified.sort(),
+    added: added.sort(),
+    deleted: deleted.sort(),
+  };
+}
+
+async function buildFilesystemStatus(projectPath) {
+  const normalizedProjectPath = path.resolve(projectPath);
+  const previousSnapshot = filesystemChangeSnapshots.get(normalizedProjectPath) ?? null;
+  const { snapshot, limitReached } = await collectFilesystemSnapshot(normalizedProjectPath);
+  filesystemChangeSnapshots.set(normalizedProjectPath, snapshot);
+  const { modified, added, deleted } = diffFilesystemSnapshots(previousSnapshot, snapshot);
+
+  return {
+    isGitRepository: false,
+    trackingMode: 'filesystem',
+    branch: null,
+    hasCommits: false,
+    modified,
+    added,
+    deleted,
+    untracked: [],
+    snapshotReady: Boolean(previousSnapshot),
+    fileCount: snapshot.size,
+    scanLimitReached: limitReached,
+  };
+}
 
 function spawnAsync(command, args, options = {}) {
   return new Promise((resolve, reject) => {
@@ -297,8 +441,9 @@ router.get('/status', async (req, res) => {
     return res.status(400).json({ error: 'Project name is required' });
   }
 
+  let projectPath;
   try {
-    const projectPath = await getActualProjectPath(project);
+    projectPath = await getActualProjectPath(project);
 
     // Validate git repository
     await validateGitRepository(projectPath);
@@ -340,6 +485,15 @@ router.get('/status', async (req, res) => {
       untracked
     });
   } catch (error) {
+    if (projectPath && isNotGitRepositoryMessage(error.message)) {
+      try {
+        res.json(await buildFilesystemStatus(projectPath));
+        return;
+      } catch (fallbackError) {
+        console.error('Filesystem status fallback error:', fallbackError);
+      }
+    }
+
     console.error('Git status error:', error);
     res.json({
       error: error.message.includes('not a git repository') || error.message.includes('Project directory is not a git repository')

package/server/routes/network.js

@@ -104,7 +104,11 @@ router.post('/tunnel', async (req, res) => {
     // required external binary is missing" — it tells the UI to show the
     // "install cloudflared/ngrok" hint rather than a generic server error.
     const status = error?.code === 'ENOENT_TUNNEL' ? 424 : 502;
-    res.status(status).json({ error: error?.message || 'Tunnel start failed', tunnel: getTunnelState() });
+    res.status(status).json({
+      error: error?.message || 'Tunnel start failed',
+      installHint: error?.installHint,
+      tunnel: getTunnelState(),
+    });
   }
 });
 

package/server/routes/taskmaster.js

@@ -13,13 +13,16 @@ import path from 'path';
 import { spawn } from 'child_process';
 
 import express from 'express';
+import crossSpawn from 'cross-spawn';
 
 import { orchestrationTaskService } from '@/modules/orchestration/tasks/orchestration-task.service.js';
 
 import { extractProjectDirectory } from '../projects.js';
 import {
     cancelInstallJob,
+    buildCliSpawnEnv,
     createInstallJob,
+    findExecutableOnPath,
     getInstallJob,
     snapshotDonePayload
 } from '../services/install-jobs.js';
@@ -34,70 +37,46 @@ const router = express.Router();
  */
 async function checkTaskMasterInstallation() {
     return new Promise((resolve) => {
-        // Check if task-master command is available
-        const child = spawn('which', ['task-master'], { 
+        const env = buildCliSpawnEnv();
+        const taskMasterPath = findExecutableOnPath('task-master', env);
+
+        if (!taskMasterPath) {
+            resolve({
+                isInstalled: false,
+                installPath: null,
+                version: null,
+                reason: 'TaskMaster CLI not found in PATH'
+            });
+            return;
+        }
+
+        const versionChild = crossSpawn(taskMasterPath, ['--version'], {
             stdio: ['ignore', 'pipe', 'pipe'],
-            shell: true 
+            env,
+            windowsHide: true,
         });
-        
-        let output = '';
-        let errorOutput = '';
-        
-        child.stdout.on('data', (data) => {
-            output += data.toString();
-        });
-        
-        child.stderr.on('data', (data) => {
-            errorOutput += data.toString();
-        });
-        
-        child.on('close', (code) => {
-            if (code === 0 && output.trim()) {
-                // TaskMaster is installed, get version
-                const versionChild = spawn('task-master', ['--version'], { 
-                    stdio: ['ignore', 'pipe', 'pipe'],
-                    shell: true 
-                });
-                
-                let versionOutput = '';
                 
-                versionChild.stdout.on('data', (data) => {
-                    versionOutput += data.toString();
-                });
+        let versionOutput = '';
                 
-                versionChild.on('close', (versionCode) => {
-                    resolve({
-                        isInstalled: true,
-                        installPath: output.trim(),
-                        version: versionCode === 0 ? versionOutput.trim() : 'unknown',
-                        reason: null
-                    });
-                });
+        versionChild.stdout?.on('data', (data) => {
+            versionOutput += data.toString();
+        });
                 
-                versionChild.on('error', () => {
-                    resolve({
-                        isInstalled: true,
-                        installPath: output.trim(),
-                        version: 'unknown',
-                        reason: null
-                    });
-                });
-            } else {
-                resolve({
-                    isInstalled: false,
-                    installPath: null,
-                    version: null,
-                    reason: 'TaskMaster CLI not found in PATH'
-                });
-            }
+        versionChild.on('close', (versionCode) => {
+            resolve({
+                isInstalled: true,
+                installPath: taskMasterPath,
+                version: versionCode === 0 ? versionOutput.trim() : 'unknown',
+                reason: null
+            });
         });
-        
-        child.on('error', (error) => {
+                
+        versionChild.on('error', () => {
             resolve({
-                isInstalled: false,
-                installPath: null,
-                version: null,
-                reason: `Error checking installation: ${error.message}`
+                isInstalled: true,
+                installPath: taskMasterPath,
+                version: 'unknown',
+                reason: null
             });
         });
     });

package/server/services/external-access.js

@@ -37,6 +37,7 @@ let tunnelState = {
   binary: null, // 'cloudflared' | 'ngrok'
   url: null,
   error: null,
+  installHint: null,
   log: [],
 };
 
@@ -66,6 +67,18 @@ const detectBinary = async () => {
   return null;
 };
 
+const createTunnelInstallHint = () => ({
+  title: 'Tunnel binary required',
+  message: 'Install cloudflared or ngrok to create a public mobile URL. Local LAN QR codes still work on the same Wi-Fi/network.',
+  commands: [
+    'macOS: brew install cloudflared',
+    'Windows: winget install Cloudflare.cloudflared',
+    'Linux: install cloudflared from https://developers.cloudflare.com/cloudflare-one/connections/connect-networks/downloads/',
+    'Alternative: install and authenticate ngrok from https://ngrok.com/download',
+  ],
+  docsUrl: 'https://developers.cloudflare.com/cloudflare-one/connections/connect-networks/downloads/',
+});
+
 const cloudflareUrlRegex = /https?:\/\/[a-z0-9.-]+trycloudflare\.com/i;
 const ngrokUrlRegex = /https?:\/\/[a-z0-9.-]+\.ngrok(-free)?\.(app|io)/i;
 
@@ -90,16 +103,18 @@ export const startTunnel = async ({ port }) => {
 
   const binary = await detectBinary();
   if (!binary) {
-    tunnelState = { running: false, binary: null, url: null, error: 'No tunnel binary found', log: [] };
+    const installHint = createTunnelInstallHint();
+    tunnelState = { running: false, binary: null, url: null, error: 'No tunnel binary found', installHint, log: [] };
     const err = new Error('No tunnel binary found (tried cloudflared, ngrok)');
     err.code = 'ENOENT_TUNNEL';
+    err.installHint = installHint;
     throw err;
   }
 
   const args = buildTunnelArgs(binary, port);
   const child = spawn(binary, args, { stdio: ['ignore', 'pipe', 'pipe'] });
   tunnelProc = child;
-  tunnelState = { running: true, binary, url: null, error: null, log: [] };
+  tunnelState = { running: true, binary, url: null, error: null, installHint: null, log: [] };
 
   const handleChunk = (chunk) => {
     const text = chunk.toString();
@@ -119,6 +134,7 @@ export const startTunnel = async ({ port }) => {
       binary,
       url: null,
       error: code === 0 ? null : `Tunnel exited with code ${code}`,
+      installHint: null,
       log: tunnelState.log,
     };
   });
@@ -138,7 +154,7 @@ export const startTunnel = async ({ port }) => {
     // If we never captured a URL, kill the child so we don't leak it.
     try { child.kill(); } catch { /* ignore */ }
     tunnelProc = null;
-    tunnelState = { ...tunnelState, running: false, error: 'Tunnel did not report a public URL' };
+    tunnelState = { ...tunnelState, running: false, error: 'Tunnel did not report a public URL', installHint: null };
     throw new Error(tunnelState.error);
   }
 
@@ -147,7 +163,7 @@ export const startTunnel = async ({ port }) => {
 
 export const stopTunnel = async () => {
   if (!tunnelProc) {
-    tunnelState = { running: false, binary: null, url: null, error: null, log: [] };
+    tunnelState = { running: false, binary: null, url: null, error: null, installHint: null, log: [] };
     return tunnelState;
   }
   try {
@@ -156,7 +172,7 @@ export const stopTunnel = async () => {
     // already dead
   }
   tunnelProc = null;
-  tunnelState = { running: false, binary: null, url: null, error: null, log: [] };
+  tunnelState = { running: false, binary: null, url: null, error: null, installHint: null, log: [] };
   return tunnelState;
 };
 

package/server/services/install-jobs.js

@@ -48,6 +48,11 @@ import spawn from 'cross-spawn';
 const jobs = new Map();
 const FINISHED_TTL_MS = 10 * 60 * 1000;
 const HARD_TIMEOUT_MS = 10 * 60 * 1000;
+const USER_SHELL_PATH_CACHE_TTL_MS = 5 * 60 * 1000;
+const userShellPathCache = {
+    value: null,
+    readAt: 0,
+};
 
 export const CLI_HOME = path.join(os.homedir(), '.pixcode', 'cli-bin');
 export const CLI_BIN_DIR = path.join(CLI_HOME, 'node_modules', '.bin');
@@ -94,13 +99,9 @@ function ensureCliHome() {
  */
 export function primeCliBinPath(env = process.env) {
     ensureCliHome();
-    const sep = process.platform === 'win32' ? ';' : ':';
-    const current = env.PATH || env.Path || '';
-    if (!current.split(sep).some((entry) => path.resolve(entry || '') === path.resolve(CLI_BIN_DIR))) {
-        const next = current ? `${CLI_BIN_DIR}${sep}${current}` : CLI_BIN_DIR;
-        env.PATH = next;
-        if ('Path' in env) env.Path = next;
-    }
+    const augmentedEnv = buildCliSpawnEnv(env);
+    env.PATH = augmentedEnv.PATH;
+    if ('Path' in env || augmentedEnv.Path) env.Path = augmentedEnv.Path || augmentedEnv.PATH;
     // Once PATH is ready, resolve any well-known provider binaries to absolute
     // paths and export them as *_CLI_PATH env vars. This side-steps a Windows
     // gotcha: `child_process.spawn('claude', …)` does NOT auto-resolve .cmd /
@@ -141,6 +142,135 @@ export function resolveProviderExecutables(env = process.env) {
     }
 }
 
+function pathSeparator() {
+    return process.platform === 'win32' ? ';' : ':';
+}
+
+function splitPathList(value) {
+    return String(value || '').split(pathSeparator()).map((entry) => entry.trim()).filter(Boolean);
+}
+
+function collectNvmNodeBins(home) {
+    const versionsDir = path.join(home, '.nvm', 'versions', 'node');
+    try {
+        return fs.readdirSync(versionsDir)
+            .map((version) => path.join(versionsDir, version, 'bin'))
+            .filter((candidate) => {
+                try {
+                    return fs.statSync(candidate).isDirectory();
+                } catch {
+                    return false;
+                }
+            })
+            .sort()
+            .reverse();
+    } catch {
+        return [];
+    }
+}
+
+function collectKnownUserBinDirs(env = process.env) {
+    const home = os.homedir();
+    if (process.platform === 'win32') {
+        return [
+            path.join(env.APPDATA || path.join(home, 'AppData', 'Roaming'), 'npm'),
+            path.join(env.LOCALAPPDATA || path.join(home, 'AppData', 'Local'), 'Programs', 'nodejs'),
+        ];
+    }
+
+    return [
+        CLI_BIN_DIR,
+        path.dirname(process.execPath),
+        ...collectNvmNodeBins(home),
+        path.join(home, '.volta', 'bin'),
+        path.join(home, '.asdf', 'shims'),
+        path.join(home, '.bun', 'bin'),
+        path.join(home, '.local', 'bin'),
+        path.join(home, '.npm-global', 'bin'),
+        '/opt/homebrew/bin',
+        '/opt/homebrew/sbin',
+        '/usr/local/bin',
+        '/usr/local/sbin',
+        '/usr/bin',
+        '/bin',
+    ];
+}
+
+export function collectUserShellPath(env = process.env) {
+    if (process.platform === 'win32') return [];
+
+    const now = Date.now();
+    if (userShellPathCache.value && now - userShellPathCache.readAt < USER_SHELL_PATH_CACHE_TTL_MS) {
+        return userShellPathCache.value;
+    }
+
+    const shells = [env.SHELL, '/bin/zsh', '/bin/bash']
+        .filter(Boolean)
+        .filter((candidate, index, list) => list.indexOf(candidate) === index)
+        .filter((candidate) => {
+            try {
+                return fs.existsSync(candidate);
+            } catch {
+                return false;
+            }
+        });
+
+    const marker = '__PIXCODE_LOGIN_PATH__=';
+    for (const shell of shells) {
+        try {
+            const output = execFileSync(shell, ['-lc', `printf '\\n${marker}%s\\n' "$PATH"`], {
+                encoding: 'utf8',
+                env,
+                timeout: 2500,
+                stdio: ['ignore', 'pipe', 'ignore'],
+            });
+            const line = output.split(/\r?\n/).reverse().find((part) => part.startsWith(marker));
+            const shellPath = line?.slice(marker.length);
+            if (shellPath) {
+                const entries = splitPathList(shellPath);
+                userShellPathCache.value = entries;
+                userShellPathCache.readAt = now;
+                return entries;
+            }
+        } catch {
+            // GUI-launched macOS apps often have a tiny PATH. If the user's
+            // shell startup files are noisy or slow, fall back to known bins.
+        }
+    }
+
+    userShellPathCache.value = [];
+    userShellPathCache.readAt = now;
+    return [];
+}
+
+function mergePathEntries(env, preferredEntries) {
+    const existing = splitPathList(env.PATH || env.Path || '');
+    const seen = new Set();
+    const merged = [];
+
+    for (const entry of [...preferredEntries, ...existing]) {
+        if (!entry) continue;
+        const key = path.resolve(entry);
+        if (seen.has(key)) continue;
+        seen.add(key);
+        merged.push(entry);
+    }
+
+    const nextPath = merged.join(pathSeparator());
+    env.PATH = nextPath;
+    if ('Path' in env) env.Path = nextPath;
+    return env;
+}
+
+export function buildCliSpawnEnv(baseEnv = process.env) {
+    const env = { ...baseEnv };
+    return mergePathEntries(env, [
+        CLI_BIN_DIR,
+        ...collectUserShellPath(baseEnv),
+        ...collectKnownUserBinDirs(baseEnv),
+    ]);
+}
+
 /**
  * Cross-platform lookup for the Claude Code CLI executable. The
  * @anthropic-ai/claude-agent-sdk SDK spawns its target with plain
@@ -301,10 +431,8 @@ export function findExecutableOnPath(name, env = process.env) {
         paths.push(path.join(env.LOCALAPPDATA || path.join(home, 'AppData', 'Local'), 'Programs', `${name}-code`));
         paths.push(path.join(env.LOCALAPPDATA || path.join(home, 'AppData', 'Local'), 'AnthropicClaude'));
     } else {
-        paths.push(path.join(home, '.local', 'bin'));
-        paths.push(path.join(home, '.npm-global', 'bin'));
-        paths.push('/usr/local/bin');
-        paths.push('/opt/homebrew/bin');
+        paths.push(...collectUserShellPath(env));
+        paths.push(...collectKnownUserBinDirs(env));
     }
 
     const exts = isWindows
@@ -331,7 +459,7 @@ export function findExecutableOnPath(name, env = process.env) {
  * more reliable than trusting PATH — when Pixcode runs as a daemon, PATH
  * is often minimal and doesn't include the user's node install.
  */
-function resolveNpmCommand() {
+function resolveNpmCommand(env = process.env) {
     const nodeDir = path.dirname(process.execPath);
     const isWindows = process.platform === 'win32';
     const candidates = isWindows
@@ -348,8 +476,11 @@ function resolveNpmCommand() {
             return siblingNpm; // we'll invoke `node <npm-cli.js>`
         }
     }
-    // Fall back to bare name and let the shell resolve.
-    return isWindows ? 'npm.cmd' : 'npm';
+
+    const resolvedFromPath = findExecutableOnPath('npm', env);
+    if (resolvedFromPath) return resolvedFromPath;
+
+    return null;
 }
 
 function packageFromCommand(installCmd) {
@@ -406,7 +537,19 @@ export function createInstallJob({ provider, installCmd, packageName }) {
     appendLog('meta', `Installing ${pkg} into ${CLI_HOME}\n`);
     appendLog('meta', `(sandboxed — no sudo / admin required)\n`);
 
-    const npmCmd = resolveNpmCommand();
+    const installEnv = buildCliSpawnEnv(process.env);
+    const npmCmd = resolveNpmCommand(installEnv);
+    if (!npmCmd) {
+        job.status = 'error';
+        job.error = 'npm was not found. Install Node.js/npm or add it to your macOS login shell PATH, then click Refresh.';
+        job.finishedAt = new Date().toISOString();
+        appendLog('stderr', job.error + '\n');
+        emitter.emit('done', buildDonePayload(job));
+        scheduleCleanup(job);
+        jobs.set(id, job);
+        return job;
+    }
+
     const useNodeRunner = npmCmd.endsWith('.js');
 
     const cmd = useNodeRunner ? process.execPath : npmCmd;
@@ -420,7 +563,7 @@ export function createInstallJob({ provider, installCmd, packageName }) {
     try {
         child = spawn(cmd, args, {
             cwd: CLI_HOME,
-            env: { ...process.env, npm_config_yes: 'true' },
+            env: { ...installEnv, npm_config_yes: 'true' },
             stdio: ['ignore', 'pipe', 'pipe'],
             windowsHide: true,
             // cross-spawn handles .cmd/.bat resolution itself — no shell