@pixelbyte-software/pixcode 1.38.3 → 1.38.5

package/scripts/smoke/command-center-non-git.mjs

@@ -0,0 +1,46 @@
+#!/usr/bin/env node
+
+import assert from 'node:assert/strict';
+import { readFileSync } from 'node:fs';
+
+const gitRoute = readFileSync('server/routes/git.js', 'utf8');
+const changedFilesHook = readFileSync('src/hooks/useChangedFilesMonitor.ts', 'utf8');
+const mainContent = readFileSync('src/components/main-content/view/MainContent.tsx', 'utf8');
+const quickSettings = readFileSync('src/components/quick-settings-panel/view/QuickSettingsContent.tsx', 'utf8');
+
+assert.ok(
+  gitRoute.includes('isGitRepository: false'),
+  'Git status route should return a structured non-git status instead of a Git operation failed error.',
+);
+
+assert.ok(
+  gitRoute.includes('filesystemChangeSnapshots'),
+  'Git status route should maintain filesystem snapshots for local-only projects.',
+);
+
+assert.ok(
+  changedFilesHook.includes('isGitRepository?: boolean'),
+  'Changed-files monitor should understand git-backed and filesystem-backed status payloads.',
+);
+
+assert.ok(
+  !changedFilesHook.includes('setError(data.details || data.error'),
+  'Changed-files monitor should not surface the non-git fallback as a blocking error.',
+);
+
+assert.ok(
+  mainContent.includes('ChangedFilesActivityRail'),
+  'Main content should render changed-file activity beside chat/orchestration, not only in Quick Settings.',
+);
+
+assert.ok(
+  mainContent.includes('setFocusedChangedFilePath(latestDetectedFile.path)'),
+  'New changes should highlight the activity rail without automatically stealing the user into the Files panel.',
+);
+
+assert.ok(
+  quickSettings.includes('changedFilesSummary'),
+  'Quick Settings should keep a compact Command Center summary instead of being the main changed-files surface.',
+);
+
+console.log('command center non-git smoke passed');

package/scripts/smoke/mobile-tunnel-guidance.mjs

@@ -0,0 +1,29 @@
+#!/usr/bin/env node
+
+import assert from 'node:assert/strict';
+import { readFileSync } from 'node:fs';
+
+const externalAccess = readFileSync('server/services/external-access.js', 'utf8');
+const mobileTab = readFileSync('src/components/settings/view/tabs/mobile-settings/MobileSettingsTab.tsx', 'utf8');
+
+assert.ok(
+  externalAccess.includes('createTunnelInstallHint'),
+  'Tunnel service should attach structured install guidance when cloudflared/ngrok is missing.',
+);
+
+assert.ok(
+  externalAccess.includes('err.installHint'),
+  'Missing tunnel binary errors should expose installHint to the route/UI.',
+);
+
+assert.ok(
+  mobileTab.includes('installHint'),
+  'Mobile settings should render tunnel install guidance from the backend response.',
+);
+
+assert.ok(
+  mobileTab.includes('external?.tunnel.installHint'),
+  'Mobile settings should keep guidance visible from persisted tunnel state.',
+);
+
+console.log('mobile tunnel guidance smoke passed');

package/scripts/smoke/notification-inapp-preference.mjs

@@ -0,0 +1,23 @@
+#!/usr/bin/env node
+
+import assert from 'node:assert/strict';
+import { readFileSync } from 'node:fs';
+
+const notificationCenter = readFileSync('src/components/notifications/InAppNotificationCenter.tsx', 'utf8');
+
+assert.ok(
+  notificationCenter.includes('inAppEnabledByPreference'),
+  'In-app notification center should explicitly read notificationPreferences.channels.inApp.',
+);
+
+assert.ok(
+  notificationCenter.includes('if (!inAppEnabled)'),
+  'In-app notification center should skip storing/opening alerts when the in-app channel is disabled.',
+);
+
+assert.ok(
+  notificationCenter.indexOf('notifyLocalEventOnce') < notificationCenter.indexOf('if (!inAppEnabled)'),
+  'Desktop/browser notification dispatch should remain independent from the in-app channel guard.',
+);
+
+console.log('notification in-app preference smoke passed');

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/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;
 };