tide-commander 1.181.0 → 1.182.0

package/dist/locales/zh-CN/terminal.json

@@ -889,6 +889,7 @@
       "agents": "代理",
       "infrastructure": "基础设施",
       "areas": "区域",
+      "files": "文件",
       "modifiedFiles": "已修改的文件",
       "recentActivity": "最近活动",
       "sessions": "历史会话"

package/dist/src/packages/server/data/builtin-skills/boss-instructions.js

@@ -204,7 +204,7 @@ Spawn ONLY when the user EXPLICITLY requests it ("create an agent", "spawn a deb
   "customInstructions": "<optional extra system prompt for this agent>",
   "codexModel": "<optional: only when provider='codex'>",
   "opencodeModel": "<optional: only when provider='opencode'>",
-  "grokModel": "<optional: only when provider='grok'>",
+  "grokModel": "<optional: only when provider='grok': grok-4.6 | grok-4.5>",
   "piModel": "<optional: only when provider='pi', 'provider/model' pattern>"
 }]
 \\\`\\\`\\\`

package/dist/src/packages/server/grok/backend.js

@@ -8,6 +8,7 @@ import { execSync } from 'child_process';
 import * as fs from 'fs';
 import * as os from 'os';
 import * as path from 'path';
+import { resolveGrokReasoningEffort } from '../../shared/agent-types.js';
 import { GrokJsonEventParser } from './json-event-parser.js';
 import { TIDE_COMMANDER_APPENDED_PROMPT } from '../prompts/tide-commander.js';
 import { getSystemPrompt, isEchoPromptEnabled } from '../services/system-prompt-service.js';
@@ -114,16 +115,12 @@ export class GrokBackend {
             args.push('-m', config.model);
         }
         if (config.effort) {
-            // Map Tide effort labels to Grok reasoning-effort values
-            const effortMap = {
-                low: 'low',
-                medium: 'medium',
-                high: 'high',
-                xHigh: 'xhigh',
-                max: 'max',
-            };
-            const mapped = effortMap[config.effort] || config.effort.toLowerCase();
-            args.push('--reasoning-effort', mapped);
+            // Map Tide effort labels to Grok reasoning-effort values, clamped to what
+            // the selected model supports (grok-4.5 has no xhigh tier; Grok has no max).
+            const mapped = resolveGrokReasoningEffort(config.model, config.effort);
+            if (mapped) {
+                args.push('--reasoning-effort', mapped);
+            }
         }
         // Session resume / fork
         if (config.sessionId) {

package/dist/src/packages/server/index.js

@@ -26,6 +26,10 @@ const HOST = process.env.HOST || (process.env.LISTEN_ALL_INTERFACES ? '::' : '12
 const HTTPS_ENABLED = process.env.HTTPS === '1';
 const TLS_KEY_PATH = process.env.TLS_KEY_PATH;
 const TLS_CERT_PATH = process.env.TLS_CERT_PATH;
+// When set, TLS is served on this port IN ADDITION to plain HTTP on PORT, so
+// http:// and https:// clients can both connect to the same instance. Takes
+// precedence over HTTPS=1 (which serves TLS on PORT and nothing in the clear).
+const HTTPS_PORT = process.env.HTTPS_PORT ? Number(process.env.HTTPS_PORT) : null;
 const FORCE_SHUTDOWN_TIMEOUT_MS = 4500;
 // ============================================================================
 // Global Error Handlers
@@ -159,26 +163,48 @@ async function main() {
     initClaudeCredentialKeepAlive();
     logger.server.log(`Data directory: ${getDataDir()}`);
     logger.server.log(`Log file: ${getLogFilePath()}`);
-    // Create Express app and HTTP server
+    // Create Express app and HTTP server(s)
     const app = createApp();
-    const server = HTTPS_ENABLED
-        ? createHttpsServer({
-            key: fs.readFileSync(assertTlsPath(TLS_KEY_PATH, 'TLS_KEY_PATH')),
-            cert: fs.readFileSync(assertTlsPath(TLS_CERT_PATH, 'TLS_CERT_PATH')),
-        }, app)
-        : createServer(app);
+    const readTlsOptions = (reason) => ({
+        key: fs.readFileSync(assertTlsPath(TLS_KEY_PATH, 'TLS_KEY_PATH', reason)),
+        cert: fs.readFileSync(assertTlsPath(TLS_CERT_PATH, 'TLS_CERT_PATH', reason)),
+    });
+    if (HTTPS_PORT && HTTPS_ENABLED) {
+        logger.server.warn('HTTPS=1 and HTTPS_PORT are both set; HTTPS_PORT wins '
+            + `(plain HTTP on ${PORT}, TLS on ${HTTPS_PORT})`);
+    }
+    // Listener set: either a single server (legacy) or HTTP + HTTPS side by side.
+    const listeners = HTTPS_PORT
+        ? [
+            { server: createServer(app), protocol: 'http', port: Number(PORT) },
+            { server: createHttpsServer(readTlsOptions('HTTPS_PORT'), app), protocol: 'https', port: HTTPS_PORT },
+        ]
+        : [{
+                server: HTTPS_ENABLED ? createHttpsServer(readTlsOptions('HTTPS=1'), app) : createServer(app),
+                protocol: HTTPS_ENABLED ? 'https' : 'http',
+                port: Number(PORT),
+            }];
+    const primary = listeners[0].server;
     const sockets = new Set();
-    server.on('connection', (socket) => {
-        sockets.add(socket);
-        socket.on('close', () => {
-            sockets.delete(socket);
+    for (const { server: listener } of listeners) {
+        listener.on('connection', (socket) => {
+            sockets.add(socket);
+            socket.on('close', () => {
+                sockets.delete(socket);
+            });
         });
-    });
-    // Initialize WebSocket
-    const wss = websocket.init(server);
+    }
+    // Initialize WebSocket. Every listener shares one WebSocketServer so clients
+    // land in the same client set no matter which scheme they arrived over.
+    const wss = websocket.init(primary);
+    for (const { server: listener } of listeners.slice(1)) {
+        websocket.attachServer(listener, wss);
+    }
     // Set up terminal WebSocket proxy for ttyd buildings
     // (HTTP proxy is set up in app.ts before API routes)
-    setupTerminalWsProxy(server);
+    for (const { server: listener } of listeners) {
+        setupTerminalWsProxy(listener);
+    }
     // Set up skill hot-reload (must be after websocket init to have broadcast available)
     skillService.setupSkillHotReload(agentService, runtimeService, websocket.broadcast);
     // Start PM2 status polling for buildings
@@ -187,22 +213,23 @@ async function main() {
     buildingService.startDockerStatusPolling(websocket.broadcast);
     // Start terminal (ttyd) status polling for buildings
     buildingService.startTerminalStatusPolling(websocket.broadcast);
-    // Start server
-    server.on('error', (err) => {
-        logger.server.error('Server listen error:', err);
-        if (err.code === 'EADDRINUSE') {
-            logger.server.error(`Port ${PORT} is already in use. Exiting.`);
-            closeFileLogging();
-            process.exit(1);
-        }
-    });
-    server.listen(Number(PORT), HOST, () => {
-        const protocol = HTTPS_ENABLED ? 'https' : 'http';
-        const wsProtocol = HTTPS_ENABLED ? 'wss' : 'ws';
-        logger.server.log(`Server running on ${protocol}://${HOST}:${PORT}`);
-        logger.server.log(`WebSocket available at ${wsProtocol}://${HOST}:${PORT}/ws`);
-        logger.server.log(`API available at ${protocol}://${HOST}:${PORT}/api`);
-    });
+    // Start server(s)
+    for (const { server: listener, protocol, port } of listeners) {
+        listener.on('error', (err) => {
+            logger.server.error(`Server listen error (${protocol}:${port}):`, err);
+            if (err.code === 'EADDRINUSE') {
+                logger.server.error(`Port ${port} is already in use. Exiting.`);
+                closeFileLogging();
+                process.exit(1);
+            }
+        });
+        listener.listen(port, HOST, () => {
+            const wsProtocol = protocol === 'https' ? 'wss' : 'ws';
+            logger.server.log(`Server running on ${protocol}://${HOST}:${port}`);
+            logger.server.log(`WebSocket available at ${wsProtocol}://${HOST}:${port}/ws`);
+            logger.server.log(`API available at ${protocol}://${HOST}:${port}/api`);
+        });
+    }
     let isShuttingDown = false;
     const gracefulShutdown = async (signal) => {
         if (isShuttingDown) {
@@ -241,7 +268,7 @@ async function main() {
             wss.clients.forEach((client) => client.terminate());
             await new Promise((resolve) => wss.close(() => resolve()));
             sockets.forEach((socket) => socket.destroy());
-            await new Promise((resolve) => server.close(() => resolve()));
+            await Promise.all(listeners.map(({ server: listener }) => (new Promise((resolve) => listener.close(() => resolve())))));
             clearTimeout(forceShutdownTimer);
             closeFileLogging();
             process.exit(0);
@@ -256,9 +283,9 @@ async function main() {
     process.on('SIGINT', () => { void gracefulShutdown('SIGINT'); });
     process.on('SIGTERM', () => { void gracefulShutdown('SIGTERM'); });
 }
-function assertTlsPath(value, envName) {
+function assertTlsPath(value, envName, reason) {
     if (!value) {
-        throw new Error(`${envName} is required when HTTPS=1`);
+        throw new Error(`${envName} is required when ${reason} is set`);
     }
     return value;
 }

package/dist/src/packages/server/routes/files.js

@@ -11,6 +11,8 @@ import { pathToFileURL } from 'url';
 import { logger } from '../utils/logger.js';
 import { loadAreas } from '../data/index.js';
 import { detectRunnerType, mightBeTestFile, mightBeVitestFile, mightBePhpTestFile } from '../services/test-runner-service.js';
+import { DEFAULT_FILE_SEARCH_EXCLUDE_DIRS, parseExcludeDirNames } from '../../shared/file-search.js';
+import { searchFilesGlobal, FILE_SEARCH_MIN_QUERY } from '../services/global-file-search.js';
 const log = logger.files;
 // Get or create temp directory for tide-commander uploads. Exported so other
 // modules (attachment-downloader, attachment-janitor) put their files under the
@@ -1201,18 +1203,20 @@ router.post('/paste', (req, res) => {
         res.status(500).json({ error: err.message });
     }
 });
-// Directories that are always skipped during file/content search. Kept as a
-// Set for O(1) lookups (this is checked once per directory entry during the
-// tree walk). Union of the old filename + content skip lists.
-const SEARCH_SKIP_DIRS = new Set([
-    'node_modules', 'dist', 'build', '.git', '__pycache__',
-    'venv', '.venv', 'target', 'vendor', '.next', '.cache',
-]);
+// Directories skipped during file/content search unless the request supplies
+// `exclude`. Kept as a Set for O(1) lookups (checked once per directory entry).
+const SEARCH_SKIP_DIRS = new Set(DEFAULT_FILE_SEARCH_EXCLUDE_DIRS);
 const MAX_SEARCH_DEPTH = 10;
+/** Request `exclude` (comma list or repeated) overrides the default skip set. */
+function skipDirsFromQuery(req) {
+    if (req.query.exclude === undefined)
+        return SEARCH_SKIP_DIRS;
+    return new Set(parseExcludeDirNames(req.query.exclude));
+}
 // Helper function to search files recursively (async / non-blocking).
 // Uses fs.promises so a deep tree walk never blocks the event loop, which
 // matters on a shared multi-agent server. `queryLower` must be pre-lowercased.
-async function searchFilesAsync(dirPath, queryLower, results, maxResults, depth = 0) {
+async function searchFilesAsync(dirPath, queryLower, results, maxResults, depth = 0, skipDirs = SEARCH_SKIP_DIRS) {
     if (results.length >= maxResults || depth > MAX_SEARCH_DEPTH)
         return;
     let entries;
@@ -1227,8 +1231,8 @@ async function searchFilesAsync(dirPath, queryLower, results, maxResults, depth
         if (results.length >= maxResults)
             break;
         const isDir = entry.isDirectory();
-        // Skip common non-essential directories
-        if (isDir && SEARCH_SKIP_DIRS.has(entry.name))
+        // Skip configured non-essential directories
+        if (isDir && skipDirs.has(entry.name))
             continue;
         const fullPath = path.join(dirPath, entry.name);
         // Check if name matches query (case-insensitive)
@@ -1255,7 +1259,7 @@ async function searchFilesAsync(dirPath, queryLower, results, maxResults, depth
     for (const sub of subdirs) {
         if (results.length >= maxResults)
             break;
-        await searchFilesAsync(sub, queryLower, results, maxResults, depth + 1);
+        await searchFilesAsync(sub, queryLower, results, maxResults, depth + 1, skipDirs);
     }
 }
 // GET /api/files/search - Search for files
@@ -1277,7 +1281,7 @@ router.get('/search', async (req, res) => {
             return;
         }
         const results = [];
-        await searchFilesAsync(dirPath, query.toLowerCase(), results, maxResults);
+        await searchFilesAsync(dirPath, query.toLowerCase(), results, maxResults, 0, skipDirsFromQuery(req));
         // Sort: files first (more likely what user wants), then by name
         results.sort((a, b) => {
             if (a.isDirectory !== b.isDirectory) {
@@ -1292,6 +1296,27 @@ router.get('/search', async (req, res) => {
         res.status(500).json({ error: err.message });
     }
 });
+// GET /api/files/search-global - Filename search across every area directory
+router.get('/search-global', async (req, res) => {
+    try {
+        const query = typeof req.query.q === 'string' ? req.query.q : '';
+        if (query.trim().length < FILE_SEARCH_MIN_QUERY) {
+            res.json({ files: [] });
+            return;
+        }
+        const limit = parseInt(String(req.query.limit ?? ''), 10);
+        const files = await searchFilesGlobal({
+            query,
+            exclude: req.query.exclude,
+            limit: Number.isFinite(limit) ? limit : undefined,
+        });
+        res.json({ files });
+    }
+    catch (err) {
+        log.error(' Global file search failed:', err);
+        res.status(500).json({ error: err.message });
+    }
+});
 // Text file extensions for content search
 const TEXT_EXTENSIONS = new Set([
     '.txt', '.md', '.markdown', '.json', '.yaml', '.yml', '.xml', '.html', '.htm',
@@ -1311,7 +1336,7 @@ const MAX_CONTENT_FILE_SIZE = 1024 * 1024;
 // a child process (never blocking the server) and is orders of magnitude faster
 // than a JS tree walk. Resolves { ok:false } when rg is missing or errors, so
 // the caller can fall back to the pure-JS walker.
-function searchFileContentsRipgrep(dirPath, query, maxResults) {
+function searchFileContentsRipgrep(dirPath, query, maxResults, skipDirs = SEARCH_SKIP_DIRS) {
     return new Promise((resolve) => {
         const args = [
             '--json',
@@ -1323,7 +1348,7 @@ function searchFileContentsRipgrep(dirPath, query, maxResults) {
             '--hidden', // include dotfiles (.env, .github, ...)
             '--no-ignore', // don't honor .gitignore (match old behavior)
             '--no-messages', // suppress permission/binary warnings on stderr
-            ...[...SEARCH_SKIP_DIRS].flatMap((d) => ['--glob', `!**/${d}/**`]),
+            ...[...skipDirs].flatMap((d) => ['--glob', `!**/${d}/**`]),
             '--',
             query,
             dirPath,
@@ -1400,7 +1425,7 @@ function searchFileContentsRipgrep(dirPath, query, maxResults) {
 // Fallback content search (async / non-blocking) used only when ripgrep is
 // unavailable. Mirrors the old behavior but with fs.promises so it never
 // blocks the event loop.
-async function searchFileContentsAsync(dirPath, queryLower, results, maxResults, depth = 0) {
+async function searchFileContentsAsync(dirPath, queryLower, results, maxResults, depth = 0, skipDirs = SEARCH_SKIP_DIRS) {
     if (results.length >= maxResults || depth > MAX_SEARCH_DEPTH)
         return;
     let entries;
@@ -1415,7 +1440,7 @@ async function searchFileContentsAsync(dirPath, queryLower, results, maxResults,
         if (results.length >= maxResults)
             break;
         if (entry.isDirectory()) {
-            if (!SEARCH_SKIP_DIRS.has(entry.name))
+            if (!skipDirs.has(entry.name))
                 subdirs.push(path.join(dirPath, entry.name));
             continue;
         }
@@ -1451,7 +1476,7 @@ async function searchFileContentsAsync(dirPath, queryLower, results, maxResults,
     for (const sub of subdirs) {
         if (results.length >= maxResults)
             break;
-        await searchFileContentsAsync(sub, queryLower, results, maxResults, depth + 1);
+        await searchFileContentsAsync(sub, queryLower, results, maxResults, depth + 1, skipDirs);
     }
 }
 // GET /api/files/search-content - Search file contents
@@ -1477,13 +1502,14 @@ router.get('/search-content', async (req, res) => {
             return;
         }
         let results = [];
-        const rg = await searchFileContentsRipgrep(dirPath, query, maxResults);
+        const skipDirs = skipDirsFromQuery(req);
+        const rg = await searchFileContentsRipgrep(dirPath, query, maxResults, skipDirs);
         if (rg.ok) {
             results = rg.results;
         }
         else {
             // ripgrep unavailable — fall back to the pure-JS async walker.
-            await searchFileContentsAsync(dirPath, query.toLowerCase(), results, maxResults);
+            await searchFileContentsAsync(dirPath, query.toLowerCase(), results, maxResults, 0, skipDirs);
         }
         res.json({ results });
     }

package/dist/src/packages/server/services/global-file-search.js

@@ -0,0 +1,281 @@
+/**
+ * Global filename search across every directory configured on areas.
+ * Used by Spotlight (GET /api/files/search-global).
+ *
+ * Prefer ripgrep (`rg --files`) when available; fall back to an async
+ * directory walk so the event loop stays unblocked.
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import { spawn } from 'child_process';
+import { loadAreas } from '../data/index.js';
+import { DEFAULT_FILE_SEARCH_EXCLUDE_DIRS, parseExcludeDirNames, } from '../../shared/file-search.js';
+function toPosixSeparators(p) {
+    return p.replace(/\\/g, '/');
+}
+export const FILE_SEARCH_MIN_QUERY = 2;
+export const FILE_SEARCH_MAX_RESULTS = 50;
+const MAX_AREA_DIRS = 48;
+const MAX_SEARCH_DEPTH = 12;
+const RG_TIMEOUT_MS = 4000;
+function defaultExcludeSet() {
+    return new Set(DEFAULT_FILE_SEARCH_EXCLUDE_DIRS);
+}
+export function excludeDirsFromInput(raw, useDefaultWhenMissing) {
+    if (raw === undefined) {
+        return useDefaultWhenMissing ? defaultExcludeSet() : new Set();
+    }
+    return new Set(parseExcludeDirNames(raw));
+}
+function gatherRoots(areas) {
+    const roots = [];
+    const seenResolved = new Set();
+    for (const area of areas) {
+        if (area.archived)
+            continue;
+        const dirs = Array.isArray(area.directories) ? area.directories : [];
+        for (const raw of dirs) {
+            if (roots.length >= MAX_AREA_DIRS)
+                return roots;
+            if (typeof raw !== 'string' || !raw.trim())
+                continue;
+            if (!path.isAbsolute(raw))
+                continue;
+            let resolved;
+            try {
+                resolved = path.resolve(raw);
+            }
+            catch {
+                continue;
+            }
+            if (seenResolved.has(resolved))
+                continue;
+            let stat;
+            try {
+                stat = fs.statSync(resolved);
+            }
+            catch {
+                continue;
+            }
+            if (!stat.isDirectory())
+                continue;
+            seenResolved.add(resolved);
+            const posixRoot = toPosixSeparators(resolved);
+            roots.push({
+                areaId: area.id,
+                areaName: area.name,
+                projectName: path.basename(resolved) || posixRoot,
+                projectRoot: posixRoot,
+                resolved,
+            });
+        }
+    }
+    return roots;
+}
+function matchRoot(filePath, roots) {
+    let best = null;
+    for (const root of roots) {
+        if (filePath === root.resolved || filePath.startsWith(root.resolved + path.sep)) {
+            if (!best || root.resolved.length > best.resolved.length)
+                best = root;
+        }
+    }
+    return best;
+}
+function toHit(filePath, root) {
+    const rel = path.relative(root.resolved, filePath);
+    return {
+        path: toPosixSeparators(filePath),
+        name: path.basename(filePath),
+        relativePath: toPosixSeparators(rel || path.basename(filePath)),
+        projectName: root.projectName,
+        projectRoot: root.projectRoot,
+        areaId: root.areaId,
+        areaName: root.areaName,
+    };
+}
+function rankHit(hit, queryLower) {
+    const name = hit.name.toLowerCase();
+    if (name === queryLower)
+        return 0;
+    if (name.startsWith(queryLower))
+        return 1;
+    if (name.includes(queryLower))
+        return 2;
+    if (hit.relativePath.toLowerCase().includes(queryLower))
+        return 3;
+    return 4;
+}
+function sortHits(hits, queryLower) {
+    return hits.sort((a, b) => {
+        const ra = rankHit(a, queryLower);
+        const rb = rankHit(b, queryLower);
+        if (ra !== rb)
+            return ra - rb;
+        if (a.name.length !== b.name.length)
+            return a.name.length - b.name.length;
+        return a.relativePath.length - b.relativePath.length;
+    });
+}
+function searchOneRootRipgrep(root, query, exclude, maxResults) {
+    return new Promise((resolve) => {
+        // cwd = project root so exclude globs like `!**/tmp/**` cannot match a
+        // host path prefix (e.g. searching a tree that lives under /tmp).
+        // Do NOT use --iglob for the query: an include glob overrides exclude
+        // globs in rg, so `tmp/Keep.ts` would leak through. Filter the query
+        // against streamed paths instead.
+        const queryLower = query.toLowerCase();
+        const args = [
+            '--files',
+            '--hidden',
+            '--no-ignore',
+            '--no-messages',
+            '--max-depth',
+            String(MAX_SEARCH_DEPTH + 1),
+            ...[...exclude].flatMap((d) => ['--glob', `!${d}/**`, '--glob', `!**/${d}/**`]),
+            '--',
+            '.',
+        ];
+        let child;
+        try {
+            child = spawn('rg', args, { cwd: root, stdio: ['ignore', 'pipe', 'pipe'] });
+        }
+        catch {
+            resolve({ ok: false, paths: [] });
+            return;
+        }
+        const paths = [];
+        let buffer = '';
+        let settled = false;
+        const finish = (ok) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            resolve({ ok, paths });
+        };
+        const timer = setTimeout(() => {
+            try {
+                child.kill();
+            }
+            catch { /* already gone */ }
+            finish(paths.length > 0);
+        }, RG_TIMEOUT_MS);
+        child.on('error', () => finish(false));
+        child.stdout?.setEncoding('utf-8');
+        child.stdout?.on('data', (chunk) => {
+            buffer += chunk;
+            let nl;
+            while ((nl = buffer.indexOf('\n')) !== -1) {
+                const line = buffer.slice(0, nl);
+                buffer = buffer.slice(nl + 1);
+                if (!line)
+                    continue;
+                const rel = line.replace(/^\.\//, '');
+                const name = path.basename(rel);
+                if (!name.toLowerCase().includes(queryLower) && !rel.toLowerCase().includes(queryLower)) {
+                    continue;
+                }
+                const abs = path.isAbsolute(line) ? line : path.join(root, line);
+                paths.push(abs);
+                if (paths.length >= maxResults) {
+                    try {
+                        child.kill();
+                    }
+                    catch { /* already gone */ }
+                    break;
+                }
+            }
+        });
+        child.on('close', (code) => {
+            // rg: 0 = matches, 1 = no matches, 2 = error.
+            finish(!(code === 2 && paths.length === 0));
+        });
+    });
+}
+async function searchFilenamesRipgrep(roots, query, exclude, maxResults) {
+    const paths = [];
+    let anyOk = false;
+    for (const root of roots) {
+        if (paths.length >= maxResults)
+            break;
+        const result = await searchOneRootRipgrep(root.resolved, query, exclude, maxResults - paths.length);
+        if (result.ok) {
+            anyOk = true;
+            paths.push(...result.paths);
+        }
+    }
+    return { ok: anyOk, paths };
+}
+async function walkForFiles(dirPath, queryLower, exclude, acc, maxResults, depth) {
+    if (acc.length >= maxResults || depth > MAX_SEARCH_DEPTH)
+        return;
+    let entries;
+    try {
+        entries = await fs.promises.readdir(dirPath, { withFileTypes: true });
+    }
+    catch {
+        return;
+    }
+    const subdirs = [];
+    for (const entry of entries) {
+        if (acc.length >= maxResults)
+            return;
+        if (entry.isDirectory()) {
+            if (exclude.has(entry.name))
+                continue;
+            subdirs.push(path.join(dirPath, entry.name));
+            continue;
+        }
+        if (!entry.isFile() && !entry.isSymbolicLink())
+            continue;
+        if (!entry.name.toLowerCase().includes(queryLower))
+            continue;
+        acc.push(path.join(dirPath, entry.name));
+    }
+    for (const sub of subdirs) {
+        if (acc.length >= maxResults)
+            return;
+        await walkForFiles(sub, queryLower, exclude, acc, maxResults, depth + 1);
+    }
+}
+export async function searchFilesGlobal(opts) {
+    const query = (opts.query || '').trim();
+    if (query.length < FILE_SEARCH_MIN_QUERY)
+        return [];
+    const limit = Math.max(1, Math.min(opts.limit ?? FILE_SEARCH_MAX_RESULTS, FILE_SEARCH_MAX_RESULTS));
+    const exclude = excludeDirsFromInput(opts.exclude, true);
+    const areas = opts.areas ?? loadAreas();
+    const roots = gatherRoots(areas);
+    if (roots.length === 0)
+        return [];
+    const queryLower = query.toLowerCase();
+    const seen = new Set();
+    const hits = [];
+    const consume = (filePath) => {
+        const resolved = path.resolve(filePath);
+        if (seen.has(resolved))
+            return;
+        const root = matchRoot(resolved, roots);
+        if (!root)
+            return;
+        seen.add(resolved);
+        hits.push(toHit(resolved, root));
+    };
+    const rg = await searchFilenamesRipgrep(roots, query, exclude, limit);
+    if (rg.ok) {
+        for (const p of rg.paths)
+            consume(p);
+    }
+    else {
+        const walked = [];
+        for (const root of roots) {
+            if (walked.length >= limit * 4)
+                break;
+            await walkForFiles(root.resolved, queryLower, exclude, walked, limit * 4, 0);
+        }
+        for (const p of walked)
+            consume(p);
+    }
+    return sortHits(hits, queryLower).slice(0, limit);
+}

package/dist/src/packages/server/websocket/handler.js

@@ -241,12 +241,15 @@ function handleClientMessage(ws, message) {
 // ============================================================================
 // Initialization
 // ============================================================================
-export function init(server) {
-    // Use noServer mode so we can manually route upgrade events.
-    // This allows the terminal proxy to handle /api/terminal/*/ws upgrades
-    // without the main WSS intercepting and rejecting them.
-    const wss = new WebSocketServer({ noServer: true });
-    // Handle upgrade events for /ws path only
+/**
+ * Route /ws upgrades from `server` into `wss`.
+ *
+ * Split out of init() so that when the server listens on both HTTP and HTTPS,
+ * the second listener shares the SAME WebSocketServer — and therefore the same
+ * client set and broadcast path. Standing up a second WebSocketServer would
+ * silently split clients into two groups, and broadcasts would only reach one.
+ */
+export function attachServer(server, wss) {
     server.on('upgrade', (request, socket, head) => {
         const pathname = request.url?.split('?')[0];
         if (pathname === '/ws') {
@@ -263,6 +266,13 @@ export function init(server) {
         }
         // Other paths (like /api/terminal/*/ws) are handled by the terminal proxy
     });
+}
+export function init(server) {
+    // Use noServer mode so we can manually route upgrade events.
+    // This allows the terminal proxy to handle /api/terminal/*/ws upgrades
+    // without the main WSS intercepting and rejecting them.
+    const wss = new WebSocketServer({ noServer: true });
+    attachServer(server, wss);
     wss.on('connection', (ws, request) => {
         clients.add(ws);
         setWsClientsCount(clients.size);