@tt-a1i/hive 1.6.0 → 2.0.1

package/dist/src/server/agent-stdin-dispatcher.js

@@ -2,6 +2,7 @@ import { FEATURE_FLAGS_ALL_OFF } from './feature-flags.js';
 import { buildOrchestratorReminderTail, buildWorkerReminderTail } from './hive-team-guidance.js';
 import { PtyInactiveError } from './http-errors.js';
 import { createPostStartInputWriter } from './post-start-input-writer.js';
+import { buildDispatchMemoryDigestSafely, logMemoryDigestInjection, rollbackMemoryDigestInjection, } from './team-memory-injection.js';
 export const buildOrchestratorReportPayload = (workerName, text, artifacts, flags = FEATURE_FLAGS_ALL_OFF) => {
     const lines = [`<hive-message kind="report" from="@${workerName}">`, text];
     for (const artifact of artifacts)
@@ -17,7 +18,7 @@ export const buildOrchestratorStatusPayload = (workerName, text, artifacts, flag
     return lines.join('\n');
 };
 export const buildOrchestratorUserInputPayload = (text, flags = FEATURE_FLAGS_ALL_OFF) => [text, '', buildOrchestratorReminderTail(flags), ''].join('\n');
-export const buildWorkerDispatchPayload = (fromAgentName, workerDescription, dispatchId, text) => [
+export const buildWorkerDispatchPayload = (fromAgentName, workerDescription, dispatchId, text, memoryDigest) => [
     `<hive-message kind="dispatch" from="@${fromAgentName}">`,
     '',
     `Your role: ${workerDescription}`,
@@ -28,6 +29,7 @@ export const buildWorkerDispatchPayload = (fromAgentName, workerDescription, dis
     '',
     `dispatch_id: ${dispatchId}`,
     '',
+    ...(memoryDigest ? [memoryDigest, ''] : []),
     'Task:',
     text,
     '</hive-message>',
@@ -45,7 +47,7 @@ export const buildWorkerCancelPayload = (dispatchId, reason) => [
     '</hive-message>',
     '',
 ].join('\n');
-export const createAgentStdinDispatcher = ({ agentManager, getLaunchConfig, getWorkspaceId, registry, syncRun, getFlags, }) => {
+export const createAgentStdinDispatcher = ({ agentManager, getLaunchConfig, getWorkspaceId, registry, syncRun, memoryInjection, getFlags, }) => {
     const flags = () => getFlags?.() ?? FEATURE_FLAGS_ALL_OFF;
     const chains = new Map();
     const getChain = (agentId) => {
@@ -163,7 +165,37 @@ export const createAgentStdinDispatcher = ({ agentManager, getLaunchConfig, getW
             swallowQueuedFailure(writeToActiveAgentRun(workspaceId, `${workspaceId}:orchestrator`, buildOrchestratorStatusPayload(workerName, text, artifacts, flags()), input));
         },
         writeSendPrompt(workspaceId, workerId, dispatchId, fromAgentName, workerDescription, text) {
-            return writeToActiveAgentRun(workspaceId, workerId, buildWorkerDispatchPayload(fromAgentName, workerDescription, dispatchId, text), { requireActiveRun: true });
+            if (!resolveActiveRun(workspaceId, workerId)) {
+                throw new PtyInactiveError(`No active run for agent: ${workerId}`);
+            }
+            const memoryDigest = buildDispatchMemoryDigestSafely({
+                memoryInjection,
+                taskText: text,
+                workerDescription,
+                workspaceId,
+            });
+            const injectionIds = logMemoryDigestInjection({
+                agentId: workerId,
+                contextType: 'dispatch',
+                dispatchId,
+                memoryDigest,
+                memoryInjection,
+                workspaceId,
+            });
+            const rollback = () => rollbackMemoryDigestInjection({
+                injectionIds,
+                memoryInjection,
+            });
+            try {
+                return writeToActiveAgentRun(workspaceId, workerId, buildWorkerDispatchPayload(fromAgentName, workerDescription, dispatchId, text, injectionIds ? memoryDigest?.text : null), { requireActiveRun: true }).catch((error) => {
+                    rollback();
+                    throw error;
+                });
+            }
+            catch (error) {
+                rollback();
+                throw error;
+            }
         },
         writeCancelPrompt(workspaceId, workerId, dispatchId, reason, input = {}) {
             swallowQueuedFailure(writeToActiveAgentRun(workspaceId, workerId, buildWorkerCancelPayload(dispatchId, reason), input));

package/dist/src/server/command-preset-defaults.d.ts

@@ -1,6 +1,8 @@
 import type { SessionIdCaptureConfig } from './session-capture.js';
+export declare const BUILTIN_COMMAND_PRESET_IDS: readonly ["claude", "codex", "opencode", "gemini", "hermes", "qwen", "agy", "cursor", "grok"];
+export type BuiltinCommandPresetId = (typeof BUILTIN_COMMAND_PRESET_IDS)[number];
 export interface BuiltinCommandPresetDefaults {
-    id: string;
+    id: BuiltinCommandPresetId;
     displayName: string;
     command: string;
     resumeArgsTemplate: string | null;
@@ -9,3 +11,6 @@ export interface BuiltinCommandPresetDefaults {
 }
 export declare const BUILTIN_COMMAND_PRESETS: BuiltinCommandPresetDefaults[];
 export declare const getBuiltinCommandPreset: (id: string) => BuiltinCommandPresetDefaults | undefined;
+export declare const getBuiltinCommandPresetByCommand: (command: string) => BuiltinCommandPresetDefaults | undefined;
+export declare const BUILTIN_COMMAND_PRESET_CLI_LIST: string;
+export declare const BUILTIN_INTERACTIVE_COMMANDS: Set<string>;

package/dist/src/server/command-preset-defaults.js

@@ -1,7 +1,23 @@
 import { CLAUDE_DEFAULT_YOLO_ARGS } from './claude-command-defaults.js';
+export const BUILTIN_COMMAND_PRESET_IDS = [
+    'claude',
+    'codex',
+    'opencode',
+    'gemini',
+    'hermes',
+    'qwen',
+    'agy',
+    'cursor',
+    'grok',
+];
 const CODEX_DEFAULT_YOLO_ARGS = ['--dangerously-bypass-approvals-and-sandbox'];
 const OPENCODE_DEFAULT_YOLO_ARGS = [];
 const GEMINI_DEFAULT_YOLO_ARGS = ['--yolo'];
+const HERMES_DEFAULT_YOLO_ARGS = ['--yolo'];
+const QWEN_DEFAULT_YOLO_ARGS = ['--approval-mode', 'yolo'];
+const AGY_DEFAULT_YOLO_ARGS = ['--dangerously-skip-permissions'];
+const CURSOR_DEFAULT_YOLO_ARGS = ['--force'];
+const GROK_DEFAULT_YOLO_ARGS = ['--always-approve'];
 export const BUILTIN_COMMAND_PRESETS = [
     {
         command: 'claude',
@@ -47,5 +63,57 @@ export const BUILTIN_COMMAND_PRESETS = [
         },
         yoloArgsTemplate: GEMINI_DEFAULT_YOLO_ARGS,
     },
+    {
+        command: 'hermes',
+        displayName: 'Hermes',
+        id: 'hermes',
+        resumeArgsTemplate: '--resume {session_id}',
+        sessionIdCapture: {
+            pattern: String.raw `Session:\s*([A-Za-z0-9_-]+)`,
+            source: 'stdout_regex',
+        },
+        yoloArgsTemplate: HERMES_DEFAULT_YOLO_ARGS,
+    },
+    {
+        command: 'qwen',
+        displayName: 'Qwen Code',
+        id: 'qwen',
+        resumeArgsTemplate: '--resume {session_id}',
+        sessionIdCapture: {
+            pattern: '~/.qwen/sessions/**/*.json',
+            source: 'qwen_session_json_dir',
+        },
+        yoloArgsTemplate: QWEN_DEFAULT_YOLO_ARGS,
+    },
+    {
+        command: 'agy',
+        displayName: 'Antigravity CLI',
+        id: 'agy',
+        resumeArgsTemplate: '--conversation {session_id}',
+        sessionIdCapture: {
+            pattern: String.raw `(?:^|\s)(?:\S*[\\/])?agy(?:\.(?:cmd|exe))?\s+--conversation\s+([0-9a-fA-F-]{36})\b`,
+            source: 'stdout_regex',
+        },
+        yoloArgsTemplate: AGY_DEFAULT_YOLO_ARGS,
+    },
+    {
+        command: 'cursor-agent',
+        displayName: 'Cursor CLI',
+        id: 'cursor',
+        resumeArgsTemplate: null,
+        sessionIdCapture: null,
+        yoloArgsTemplate: CURSOR_DEFAULT_YOLO_ARGS,
+    },
+    {
+        command: 'grok',
+        displayName: 'Grok Build',
+        id: 'grok',
+        resumeArgsTemplate: null,
+        sessionIdCapture: null,
+        yoloArgsTemplate: GROK_DEFAULT_YOLO_ARGS,
+    },
 ];
 export const getBuiltinCommandPreset = (id) => BUILTIN_COMMAND_PRESETS.find((preset) => preset.id === id);
+export const getBuiltinCommandPresetByCommand = (command) => BUILTIN_COMMAND_PRESETS.find((preset) => preset.command === command);
+export const BUILTIN_COMMAND_PRESET_CLI_LIST = BUILTIN_COMMAND_PRESET_IDS.join('|');
+export const BUILTIN_INTERACTIVE_COMMANDS = new Set(BUILTIN_COMMAND_PRESETS.flatMap((preset) => [preset.id, preset.command]));

package/dist/src/server/fs-browse.d.ts

@@ -21,6 +21,8 @@ export interface FsProbeResponse {
     path: string;
     suggested_name: string;
 }
+export declare const getWindowsBrowseParentPath: (candidate: string) => string;
+export declare const getSuggestedWorkspaceNameFromPath: (path: string) => string;
 export declare const browseDirectory: (requestedPath: string) => Promise<FsBrowseResponse>;
 export interface ProbeDirectoryOptions {
     /**

package/dist/src/server/fs-browse.js

@@ -1,10 +1,9 @@
-import { execFile } from 'node:child_process';
-import { readdir, stat } from 'node:fs/promises';
-import { dirname, resolve } from 'node:path';
-import { promisify } from 'node:util';
-import { getFsBrowseRoot, isPathWithinRoot } from './fs-sandbox.js';
-const execFileP = promisify(execFile);
-const GIT_BRANCH_TIMEOUT_MS = 800;
+import { readdir, readFile, stat } from 'node:fs/promises';
+import { dirname, isAbsolute, resolve } from 'node:path';
+import { dirname as dirnameWin32Path, parse as parseWin32Path, resolve as resolveWin32Path, } from 'node:path/win32';
+import { WINDOWS_DRIVES_ROOT } from '../shared/fs-browse.js';
+import { sanitizePastedPath } from '../shared/path-input.js';
+import { getFsBrowseRoot, hasFsBrowseRootOverride, isPathWithinRoot } from './fs-sandbox.js';
 /**
  * Map a filesystem rejection (from `readdir`, `stat`, etc.) to a string
  * suitable for surfacing in the browse response. The common Windows
@@ -28,31 +27,94 @@ const formatFilesystemError = (error) => {
     }
     return error.message;
 };
-const detectGitRepository = async (entryPath) => {
+const resolveGitDirPath = async (repoPath) => {
+    const dotGitPath = resolve(repoPath, '.git');
     try {
-        const info = await stat(resolve(entryPath, '.git'));
-        return info.isDirectory() || info.isFile();
+        const info = await stat(dotGitPath);
+        if (info.isDirectory())
+            return dotGitPath;
+        if (!info.isFile())
+            return null;
+        const text = await readFile(dotGitPath, 'utf8');
+        const firstLine = text.split(/\r?\n/u)[0]?.trim() ?? '';
+        const match = /^gitdir:\s*(?<path>.+)$/iu.exec(firstLine);
+        const gitDirPath = match?.groups?.path?.trim();
+        if (!gitDirPath)
+            return null;
+        return isAbsolute(gitDirPath) ? gitDirPath : resolve(repoPath, gitDirPath);
     }
     catch {
-        return false;
+        return null;
     }
 };
+const detectGitRepository = async (entryPath) => (await resolveGitDirPath(entryPath)) !== null;
 const readCurrentBranch = async (repoPath) => {
+    const gitDirPath = await resolveGitDirPath(repoPath);
+    if (!gitDirPath)
+        return null;
     try {
-        const { stdout } = await execFileP('git', ['-C', repoPath, 'rev-parse', '--abbrev-ref', 'HEAD'], {
-            timeout: GIT_BRANCH_TIMEOUT_MS,
-            windowsHide: true,
-        });
-        const branch = stdout.trim();
-        return branch.length > 0 ? branch : null;
+        const head = (await readFile(resolve(gitDirPath, 'HEAD'), 'utf8')).split(/\r?\n/u)[0]?.trim();
+        const branchRef = head?.startsWith('ref: refs/heads/')
+            ? head.slice('ref: refs/heads/'.length)
+            : '';
+        return branchRef.length > 0 ? branchRef : null;
     }
     catch {
         return null;
     }
 };
+const isFullWindowsBrowseEnabled = () => process.platform === 'win32' && !hasFsBrowseRootOverride();
+const trimTrailingWindowsSeparators = (path) => path.replace(/[\\/]+$/u, '');
+const isWindowsRootPath = (path) => {
+    const resolved = resolveWin32Path(path);
+    const parsed = parseWin32Path(resolved);
+    return (parsed.root.length > 0 &&
+        trimTrailingWindowsSeparators(resolved).toLowerCase() ===
+            trimTrailingWindowsSeparators(parsed.root).toLowerCase());
+};
+const listWindowsDriveRoots = async () => {
+    const letters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'.split('');
+    const roots = await Promise.all(letters.map(async (letter) => {
+        const root = `${letter}:\\`;
+        try {
+            const info = await stat(root);
+            if (!info.isDirectory())
+                return null;
+            return {
+                is_dir: true,
+                is_git_repository: false,
+                name: `${letter}:`,
+                path: root,
+            };
+        }
+        catch {
+            return null;
+        }
+    }));
+    return roots.filter((root) => root !== null);
+};
+const browseWindowsDrivesRoot = async () => ({
+    current_path: WINDOWS_DRIVES_ROOT,
+    entries: await listWindowsDriveRoots(),
+    error: null,
+    ok: true,
+    parent_path: null,
+    root_path: WINDOWS_DRIVES_ROOT,
+});
+const getSandboxParentPath = (rootPath, candidate) => {
+    if (candidate === rootPath)
+        return null;
+    const rawParent = dirname(candidate);
+    return isPathWithinRoot(rootPath, rawParent) ? rawParent : null;
+};
+export const getWindowsBrowseParentPath = (candidate) => isWindowsRootPath(candidate) ? WINDOWS_DRIVES_ROOT : dirnameWin32Path(candidate);
+export const getSuggestedWorkspaceNameFromPath = (path) => (path.split(/[\\/]/).filter(Boolean).pop() ?? '').replace(/:$/u, '');
 export const browseDirectory = async (requestedPath) => {
+    if (isFullWindowsBrowseEnabled()) {
+        return browseWindowsDirectory(requestedPath);
+    }
     const rootPath = getFsBrowseRoot();
-    const trimmed = requestedPath.trim();
+    const trimmed = sanitizePastedPath(requestedPath);
     const candidate = trimmed.length === 0 ? rootPath : resolve(rootPath, trimmed);
     if (!isPathWithinRoot(rootPath, candidate)) {
         return {
@@ -74,7 +136,7 @@ export const browseDirectory = async (requestedPath) => {
             entries: [],
             error: formatFilesystemError(error),
             ok: false,
-            parent_path: null,
+            parent_path: getSandboxParentPath(rootPath, candidate),
             root_path: rootPath,
         };
     }
@@ -84,7 +146,7 @@ export const browseDirectory = async (requestedPath) => {
             entries: [],
             error: 'The specified path is not a directory.',
             ok: false,
-            parent_path: null,
+            parent_path: getSandboxParentPath(rootPath, candidate),
             root_path: rootPath,
         };
     }
@@ -102,7 +164,7 @@ export const browseDirectory = async (requestedPath) => {
             entries: [],
             error: formatFilesystemError(error),
             ok: false,
-            parent_path: null,
+            parent_path: getSandboxParentPath(rootPath, candidate),
             root_path: rootPath,
         };
     }
@@ -118,25 +180,97 @@ export const browseDirectory = async (requestedPath) => {
             path: entryPath,
         };
     }));
-    const isAtRoot = candidate === rootPath;
-    const rawParent = dirname(candidate);
-    const parentIsWithinRoot = isPathWithinRoot(rootPath, rawParent);
-    const parent_path = isAtRoot ? null : parentIsWithinRoot ? rawParent : null;
     return {
         current_path: candidate,
         entries,
         error: null,
         ok: true,
-        parent_path,
+        parent_path: getSandboxParentPath(rootPath, candidate),
         root_path: rootPath,
     };
 };
+const browseWindowsDirectory = async (requestedPath) => {
+    const trimmed = sanitizePastedPath(requestedPath);
+    if (trimmed.length === 0 || trimmed === WINDOWS_DRIVES_ROOT) {
+        return browseWindowsDrivesRoot();
+    }
+    const candidate = resolveWin32Path(trimmed);
+    let dirStat;
+    try {
+        dirStat = await stat(candidate);
+    }
+    catch (error) {
+        return {
+            current_path: candidate,
+            entries: [],
+            error: formatFilesystemError(error),
+            ok: false,
+            parent_path: getWindowsBrowseParentPath(candidate),
+            root_path: WINDOWS_DRIVES_ROOT,
+        };
+    }
+    if (!dirStat.isDirectory()) {
+        return {
+            current_path: candidate,
+            entries: [],
+            error: 'The specified path is not a directory.',
+            ok: false,
+            parent_path: getWindowsBrowseParentPath(candidate),
+            root_path: WINDOWS_DRIVES_ROOT,
+        };
+    }
+    let rawEntries;
+    try {
+        rawEntries = await readdir(candidate, { withFileTypes: true });
+    }
+    catch (error) {
+        return {
+            current_path: candidate,
+            entries: [],
+            error: formatFilesystemError(error),
+            ok: false,
+            parent_path: getWindowsBrowseParentPath(candidate),
+            root_path: WINDOWS_DRIVES_ROOT,
+        };
+    }
+    const directoryEntries = rawEntries
+        .filter((entry) => entry.isDirectory() && !entry.name.startsWith('.'))
+        .sort((a, b) => a.name.localeCompare(b.name));
+    const entries = await Promise.all(directoryEntries.map(async (entry) => {
+        const entryPath = resolveWin32Path(candidate, entry.name);
+        return {
+            is_dir: true,
+            is_git_repository: await detectGitRepository(entryPath),
+            name: entry.name,
+            path: entryPath,
+        };
+    }));
+    return {
+        current_path: candidate,
+        entries,
+        error: null,
+        ok: true,
+        parent_path: getWindowsBrowseParentPath(candidate),
+        root_path: WINDOWS_DRIVES_ROOT,
+    };
+};
 export const probeDirectory = async (requestedPath, options = {}) => {
     const enforceSandbox = options.enforceSandbox ?? true;
+    const fullWindowsBrowse = isFullWindowsBrowseEnabled();
+    const requested = sanitizePastedPath(requestedPath);
+    if (requested === WINDOWS_DRIVES_ROOT) {
+        return {
+            current_branch: null,
+            exists: false,
+            is_dir: false,
+            is_git_repository: false,
+            ok: false,
+            path: '',
+            suggested_name: '',
+        };
+    }
     const rootPath = getFsBrowseRoot();
-    const candidate = enforceSandbox
-        ? resolve(rootPath, requestedPath.trim())
-        : resolve(requestedPath.trim());
+    const candidate = enforceSandbox && !fullWindowsBrowse ? resolve(rootPath, requested) : resolve(requested);
     const base = {
         current_branch: null,
         exists: false,
@@ -144,9 +278,9 @@ export const probeDirectory = async (requestedPath, options = {}) => {
         is_git_repository: false,
         ok: false,
         path: candidate,
-        suggested_name: candidate.split(/[\\/]/).filter(Boolean).pop() ?? '',
+        suggested_name: getSuggestedWorkspaceNameFromPath(candidate),
     };
-    if (enforceSandbox && !isPathWithinRoot(rootPath, candidate)) {
+    if (enforceSandbox && !fullWindowsBrowse && !isPathWithinRoot(rootPath, candidate)) {
         return base;
     }
     try {

package/dist/src/server/fs-pick-folder.js

@@ -95,73 +95,6 @@ const linuxPick = async (run) => {
         return emptyResponse({ canceled: true });
     return finalizeWithProbe(picked);
 };
-const windowsPick = async (run) => {
-    /* Hive's PowerShell child has no visible main window, so a bare
-       `$dialog.ShowDialog()` inherits the desktop as IWin32Window parent —
-       and ends up below the foreground browser in z-order. To the user
-       that looks like a hang ("Add Workspace pops up then nothing"); the
-       picker is open, just occluded.
-  
-       Fix: build a TopMost invisible owner Form, `Show()` it so it has a
-       real HWND (an unshown Form has none, and ShowDialog silently falls
-       back to desktop-parent), then pass the owner to `ShowDialog($owner)`.
-       The owner inherits TopMost z-order onto the dialog. The owner itself
-       stays invisible — Opacity 0, parked at (-32000, -32000), 1x1 size,
-       no taskbar entry — so the user only sees the picker. Dispose in
-       `finally` to release the HWND each invocation.
-  
-       `Add-Type -AssemblyName System.Drawing` is required because Point /
-       Size live in System.Drawing.dll, not System.Windows.Forms.dll. */
-    // PS 5.1 on zh-CN Windows defaults [Console]::OutputEncoding to cp936/GBK;
-    // Node decodes stdout as UTF-8 and CJK paths arrive mojibake'd. Force UTF-8
-    // before any output. No-op on PS 7+ which already defaults to UTF-8.
-    const script = [
-        '[Console]::OutputEncoding = [System.Text.Encoding]::UTF8',
-        'Add-Type -AssemblyName System.Windows.Forms',
-        'Add-Type -AssemblyName System.Drawing',
-        '$owner = New-Object System.Windows.Forms.Form',
-        "$owner.FormBorderStyle = 'None'",
-        '$owner.Opacity = 0',
-        '$owner.ShowInTaskbar = $false',
-        "$owner.StartPosition = 'Manual'",
-        '$owner.Location = New-Object System.Drawing.Point(-32000, -32000)',
-        '$owner.Size = New-Object System.Drawing.Size(1, 1)',
-        '$owner.TopMost = $true',
-        '$owner.Show()',
-        'try {',
-        '  $dialog = New-Object System.Windows.Forms.FolderBrowserDialog',
-        '  $dialog.Description = "Select Hive workspace"',
-        '  $dialog.ShowNewFolderButton = $false',
-        '  $result = $dialog.ShowDialog($owner)',
-        '  if ($result -eq [System.Windows.Forms.DialogResult]::OK) { [Console]::Out.WriteLine($dialog.SelectedPath); exit 0 }',
-        '  exit 1',
-        '} finally {',
-        '  $owner.Close()',
-        '  $owner.Dispose()',
-        '}',
-    ].join('; ');
-    const result = await run('powershell.exe', ['-NoProfile', '-STA', '-ExecutionPolicy', 'Bypass', '-Command', script], { timeout: PICKER_TIMEOUT_MS });
-    if (result.spawnError?.code === 'ENOENT') {
-        return emptyResponse({
-            error: 'PowerShell is unavailable on this host. Use Advanced: paste path.',
-            supported: false,
-        });
-    }
-    if (result.timedOut) {
-        return emptyResponse({ error: 'Folder picker timed out before a folder was selected.' });
-    }
-    if (result.status !== 0) {
-        const stderr = result.stderr.trim();
-        if (stderr.length > 0) {
-            return emptyResponse({ error: `Folder picker failed: ${stderr}` });
-        }
-        return emptyResponse({ canceled: true });
-    }
-    const picked = result.stdout.trim();
-    if (picked.length === 0)
-        return emptyResponse({ canceled: true });
-    return finalizeWithProbe(picked);
-};
 export const pickFolder = async (options = {}) => {
     const platform = options.platform ?? process.platform;
     const run = options.runCommand ?? defaultRunCommand;
@@ -169,8 +102,12 @@ export const pickFolder = async (options = {}) => {
         return macOsPick(run);
     if (platform === 'linux')
         return linuxPick(run);
-    if (platform === 'win32')
-        return windowsPick(run);
+    if (platform === 'win32') {
+        return emptyResponse({
+            error: 'Native folder picker is disabled on Windows. Use Browse server filesystem or paste path.',
+            supported: false,
+        });
+    }
     return emptyResponse({
         error: 'Native folder picker not supported on this platform. Use Advanced: paste path.',
         supported: false,

package/dist/src/server/fs-sandbox.d.ts

@@ -1,9 +1,11 @@
 /**
- * Root directory the FS-browse API is allowed to reveal. We sandbox to
- * `$HOME` (override via `HIVE_FS_BROWSE_ROOT` for tests). Anything outside
- * this prefix is rejected before readdir/stat even runs.
+ * Root directory the FS-browse API is allowed to reveal when sandboxing is
+ * enabled. Tests and remote/headless setups can set `HIVE_FS_BROWSE_ROOT`.
+ * Normal Windows runs skip this sandbox root and browse from the virtual
+ * "This PC" drive list; POSIX sandboxed browsing defaults to `$HOME`.
  */
 export declare const getFsBrowseRoot: () => string;
+export declare const hasFsBrowseRootOverride: () => boolean;
 /**
  * True when `candidatePath` is `rootPath` itself or a descendant of it.
  * Uses `path.relative` + separator check so Windows back-slashes and drive

package/dist/src/server/fs-sandbox.js

@@ -2,9 +2,10 @@ import { homedir } from 'node:os';
 import { isAbsolute, relative, resolve, sep } from 'node:path';
 import { realpathNative } from './path-canonicalization.js';
 /**
- * Root directory the FS-browse API is allowed to reveal. We sandbox to
- * `$HOME` (override via `HIVE_FS_BROWSE_ROOT` for tests). Anything outside
- * this prefix is rejected before readdir/stat even runs.
+ * Root directory the FS-browse API is allowed to reveal when sandboxing is
+ * enabled. Tests and remote/headless setups can set `HIVE_FS_BROWSE_ROOT`.
+ * Normal Windows runs skip this sandbox root and browse from the virtual
+ * "This PC" drive list; POSIX sandboxed browsing defaults to `$HOME`.
  */
 export const getFsBrowseRoot = () => {
     const override = process.env.HIVE_FS_BROWSE_ROOT;
@@ -16,6 +17,7 @@ export const getFsBrowseRoot = () => {
         return root;
     }
 };
+export const hasFsBrowseRootOverride = () => (process.env.HIVE_FS_BROWSE_ROOT ?? '').length > 0;
 const isResolvedPathWithinRoot = (rootPath, candidatePath) => {
     if (candidatePath === rootPath)
         return true;