nastechai-desktop 18.1.0

package/electron/desktop-uninstall.cjs

@@ -0,0 +1,232 @@
+/**
+ * desktop-uninstall.cjs
+ *
+ * Pure, electron-free helpers for the desktop Chat GUI uninstaller. These map
+ * the three user-facing uninstall modes to the `nastech uninstall` CLI flags,
+ * resolve the running app bundle/exe so a detached cleanup script can remove
+ * it after the app quits, and build that cleanup script for each OS.
+ *
+ * Kept standalone (no `require('electron')`) so it can be unit-tested with
+ * `node --test` — same pattern as connection-config.cjs / backend-probes.cjs.
+ * main.cjs requires these and wires them into the electron-coupled IPC layer.
+ *
+ * The three modes mirror the CLI's options exactly:
+ *   - 'gui'  → remove ONLY the Chat GUI, keep the agent + all user data.
+ *              `nastech uninstall --gui --yes`
+ *   - 'lite' → remove the GUI + agent code, KEEP user data (config / sessions
+ *              / .env) for a future reinstall. `nastech uninstall --yes`
+ *   - 'full' → remove everything: GUI + agent + all user data.
+ *              `nastech uninstall --full --yes`
+ *
+ * Why a detached cleanup script: 'lite'/'full' delete the very venv the
+ * `nastech` command runs from, and every mode may need to delete the running
+ * app bundle (locked on macOS/Windows while the process is alive). So we hand
+ * the work to a detached child that waits for this app's PID to exit, runs the
+ * Python uninstall, then removes the app bundle — then the app quits. Same
+ * shape as the self-update swap-and-relaunch flow already in main.cjs.
+ */
+
+const path = require('node:path')
+
+const UNINSTALL_MODES = ['gui', 'lite', 'full']
+
+/**
+ * Map an uninstall mode to the `python -m nastech_cli.uninstall` argv (after the
+ * python executable). Uses the dedicated lightweight module entrypoint (not
+ * `nastech_cli.main`) so it can run under a system Python OUTSIDE the venv that
+ * lite/full delete — see the Finding-3 note in buildWindowsCleanupScript.
+ * Throws on an unknown mode so a typo can't silently become a full wipe.
+ */
+function uninstallArgsForMode(mode) {
+  if (!UNINSTALL_MODES.includes(mode)) {
+    throw new Error(`Unknown uninstall mode: ${mode}`)
+  }
+  return ['-m', 'nastech_cli.uninstall', '--mode', mode]
+}
+
+/** True when `mode` removes the agent (lite/full), false for gui-only. */
+function modeRemovesAgent(mode) {
+  return mode === 'lite' || mode === 'full'
+}
+
+/** True when `mode` removes user data (full only). */
+function modeRemovesUserData(mode) {
+  return mode === 'full'
+}
+
+/**
+ * Resolve the on-disk app bundle/dir to remove for the running desktop app,
+ * given the path to the running executable (`process.execPath`) and platform.
+ *
+ *   macOS:   …/NasTech.app/Contents/MacOS/NasTech  → …/NasTech.app
+ *   Windows: …\NasTech\NasTech.exe                 → …\NasTech  (install dir)
+ *   Linux:   AppImage → the APPIMAGE env path; unpacked → the *-unpacked dir
+ *
+ * Returns null when we can't confidently identify a removable bundle (e.g.
+ * running from a dev checkout, or a system-package install we must not rmtree).
+ */
+function resolveRemovableAppPath(execPath, platform, env = {}) {
+  const exe = String(execPath || '')
+  if (!exe) return null
+
+  // Use the path flavor that matches the TARGET platform, not the host running
+  // this code — so the Windows branch parses backslash paths correctly even
+  // when these pure helpers are unit-tested on Linux/macOS CI.
+  const p = platform === 'win32' ? path.win32 : path.posix
+
+  if (platform === 'darwin') {
+    // …/NasTech.app/Contents/MacOS/NasTech → strip 3 segments to the .app
+    const macOsDir = p.dirname(exe) // …/Contents/MacOS
+    const contents = p.dirname(macOsDir) // …/Contents
+    const appBundle = p.dirname(contents) // …/NasTech.app
+    if (appBundle.endsWith('.app')) return appBundle
+    return null
+  }
+
+  if (platform === 'win32') {
+    // NSIS per-user installs NasTech.exe directly in the install dir.
+    const dir = p.dirname(exe)
+    if (/[\\/]NasTech$/i.test(dir) || /[\\/]nastech-desktop$/i.test(dir)) return dir
+    return null
+  }
+
+  // Linux: an AppImage exposes its own path via the APPIMAGE env var.
+  if (env.APPIMAGE) return env.APPIMAGE
+  // Unpacked electron-builder tree: …/linux-unpacked/nastech
+  const dir = p.dirname(exe)
+  if (/-unpacked$/.test(dir)) return dir
+  return null
+}
+
+/**
+ * Should we even try to remove the running app bundle from a cleanup script?
+ * Only when packaged AND we resolved a concrete removable path. Dev runs
+ * (electron from node_modules) and system-package installs return null above
+ * and are left to the OS package manager.
+ */
+function shouldRemoveAppBundle(isPackaged, appPath) {
+  return Boolean(isPackaged) && Boolean(appPath)
+}
+
+/**
+ * Build a POSIX cleanup shell script (macOS / Linux). It:
+ *   1. waits (bounded ~30s) for the desktop PID to exit (venv/bundle unlock),
+ *   2. runs the Python uninstall module with the mode,
+ *   3. removes the app bundle if one was resolved.
+ *
+ * `pythonExe` should be a Python OUTSIDE the venv for lite/full (the venv is
+ * being deleted); `pythonPath` is prepended to PYTHONPATH so `import nastech_cli`
+ * resolves from the agent source. `q()` single-quote-escapes for the shell
+ * (closes-escapes-reopens any embedded apostrophe), defending against spaces.
+ */
+function buildPosixCleanupScript({ desktopPid, pythonExe, pythonPath, agentRoot, uninstallArgs, appPath, nastechHome }) {
+  const q = s => `'${String(s).replace(/'/g, `'\\''`)}'`
+  const lines = [
+    '#!/bin/bash',
+    'set -u',
+    '# Wait (up to ~30s) for the desktop process to exit so the venv python',
+    '# and the app bundle are no longer in use.',
+    `pid=${Number(desktopPid) || 0}`,
+    'if [ "$pid" -gt 0 ]; then',
+    '  for _ in $(seq 1 60); do',
+    '    kill -0 "$pid" 2>/dev/null || break',
+    '    sleep 0.5',
+    '  done',
+    'fi',
+    `export NASTECH_HOME=${q(nastechHome)}`
+  ]
+  if (pythonPath) {
+    lines.push(`export PYTHONPATH=${q(pythonPath)}\${PYTHONPATH:+:$PYTHONPATH}`)
+  }
+  lines.push(
+    `cd ${q(agentRoot)} 2>/dev/null || true`,
+    `${q(pythonExe)} ${uninstallArgs.map(q).join(' ')} || true`
+  )
+  if (appPath) {
+    lines.push(`rm -rf ${q(appPath)} || true`)
+  }
+  // Self-delete the script.
+  lines.push('rm -f "$0" 2>/dev/null || true')
+  lines.push('')
+  return lines.join('\n')
+}
+
+/**
+ * Build a Windows cleanup batch script. Same three steps, cmd.exe flavored.
+ *
+ * Finding 3 (venv self-deletion): for lite/full the agent uninstall rmtree's
+ * the venv that contains `python.exe`. A running .exe is mandatory-locked on
+ * Windows, so running the uninstall from the venv's OWN python half-fails. The
+ * desktop passes a system Python (findSystemPython) as `pythonExe` for those
+ * modes + `pythonPath`=agentRoot so `import nastech_cli` resolves from source
+ * while the venv is torn down. gui-only doesn't touch the venv, so it can use
+ * either interpreter.
+ *
+ * Wait-loop: bounded (matches POSIX's ~30s cap) so a never-exiting / mismatched
+ * PID can't wedge the cleanup forever. The `/FI "PID eq"` filter is an EXACT
+ * match, so no redundant `| find` (which would substring-match 99→990).
+ *
+ * Removal: even after the desktop PID is gone, Windows releases directory
+ * handles lazily, so a single `rmdir /s /q` can half-fail — retry up to 10x.
+ */
+function buildWindowsCleanupScript({ desktopPid, pythonExe, pythonPath, agentRoot, uninstallArgs, appPath, nastechHome }) {
+  const pid = Number(desktopPid) || 0
+  // cmd.exe has no string escaping inside quotes; strip embedded quotes (paths
+  // under %LOCALAPPDATA% never contain them). `&`/`^` in a path would still be
+  // a problem, but NasTech install paths don't use them.
+  const q = s => `"${String(s).replace(/"/g, '')}"`
+  const lines = [
+    '@echo off',
+    'setlocal enableextensions',
+    `set "NASTECH_HOME=${String(nastechHome).replace(/"/g, '')}"`,
+    `set "PID=${pid}"`
+  ]
+  if (pythonPath) {
+    lines.push(`set "PYTHONPATH=${String(pythonPath).replace(/"/g, '')};%PYTHONPATH%"`)
+  }
+  lines.push(
+    'set /a waited=0',
+    ':waitloop',
+    'rem /FI "PID eq %PID%" is an EXACT filter — tasklist outputs the one task',
+    'rem row for that PID, or "INFO: No tasks..." otherwise. /NH drops the',
+    'rem header; findstr matches the PID as a whole space-delimited token so',
+    'rem PID 99 cannot match 990 (the substring trap of a bare `find`).',
+    'tasklist /NH /FI "PID eq %PID%" 2>nul | findstr /r /c:" %PID% " >nul',
+    'if %ERRORLEVEL% neq 0 goto waited_done',
+    'set /a waited+=1',
+    'if %waited% geq 60 goto waited_done',
+    'timeout /t 1 /nobreak >nul',
+    'goto waitloop',
+    ':waited_done',
+    `cd /d ${q(agentRoot)}`,
+    `${q(pythonExe)} ${uninstallArgs.map(q).join(' ')}`
+  )
+  if (appPath) {
+    lines.push(
+      'set /a tries=0',
+      ':rmloop',
+      `if not exist ${q(appPath)} goto rmdone`,
+      `rmdir /s /q ${q(appPath)} >nul 2>&1`,
+      `if not exist ${q(appPath)} goto rmdone`,
+      'set /a tries+=1',
+      'if %tries% geq 10 goto rmdone',
+      'timeout /t 1 /nobreak >nul',
+      'goto rmloop',
+      ':rmdone'
+    )
+  }
+  lines.push('del "%~f0"')
+  lines.push('')
+  return lines.join('\r\n')
+}
+
+module.exports = {
+  UNINSTALL_MODES,
+  buildPosixCleanupScript,
+  buildWindowsCleanupScript,
+  modeRemovesAgent,
+  modeRemovesUserData,
+  resolveRemovableAppPath,
+  shouldRemoveAppBundle,
+  uninstallArgsForMode
+}

package/electron/desktop-uninstall.test.cjs

@@ -0,0 +1,246 @@
+/**
+ * Tests for electron/desktop-uninstall.cjs.
+ *
+ * Run with: node --test electron/desktop-uninstall.test.cjs
+ * (Wired into npm test:desktop:platforms in package.json.)
+ *
+ * These are the pure helpers behind the desktop Chat GUI uninstaller: the
+ * mode → CLI-flag mapping, the running-app-bundle resolution per OS, and the
+ * cleanup-script builders (POSIX + Windows).
+ */
+
+const test = require('node:test')
+const assert = require('node:assert/strict')
+
+const {
+  UNINSTALL_MODES,
+  buildPosixCleanupScript,
+  buildWindowsCleanupScript,
+  modeRemovesAgent,
+  modeRemovesUserData,
+  resolveRemovableAppPath,
+  shouldRemoveAppBundle,
+  uninstallArgsForMode
+} = require('./desktop-uninstall.cjs')
+
+// --- uninstallArgsForMode ---
+
+test('uninstallArgsForMode maps each mode to the module-runner argv', () => {
+  assert.deepEqual(uninstallArgsForMode('gui'), ['-m', 'nastech_cli.uninstall', '--mode', 'gui'])
+  assert.deepEqual(uninstallArgsForMode('lite'), ['-m', 'nastech_cli.uninstall', '--mode', 'lite'])
+  assert.deepEqual(uninstallArgsForMode('full'), ['-m', 'nastech_cli.uninstall', '--mode', 'full'])
+})
+
+test('uninstallArgsForMode throws on an unknown mode (no silent full wipe)', () => {
+  assert.throws(() => uninstallArgsForMode('nuke'), /Unknown uninstall mode/)
+  assert.throws(() => uninstallArgsForMode(''), /Unknown uninstall mode/)
+})
+
+test('UNINSTALL_MODES lists exactly the three supported modes', () => {
+  assert.deepEqual([...UNINSTALL_MODES].sort(), ['full', 'gui', 'lite'])
+})
+
+// --- modeRemovesAgent / modeRemovesUserData ---
+
+test('mode predicates classify what each mode removes', () => {
+  assert.equal(modeRemovesAgent('gui'), false)
+  assert.equal(modeRemovesAgent('lite'), true)
+  assert.equal(modeRemovesAgent('full'), true)
+
+  assert.equal(modeRemovesUserData('gui'), false)
+  assert.equal(modeRemovesUserData('lite'), false)
+  assert.equal(modeRemovesUserData('full'), true)
+})
+
+// --- resolveRemovableAppPath ---
+
+test('resolveRemovableAppPath finds the .app bundle on macOS', () => {
+  assert.equal(
+    resolveRemovableAppPath('/Applications/NasTech.app/Contents/MacOS/NasTech', 'darwin'),
+    '/Applications/NasTech.app'
+  )
+  assert.equal(
+    resolveRemovableAppPath('/Users/x/Applications/NasTech.app/Contents/MacOS/NasTech', 'darwin'),
+    '/Users/x/Applications/NasTech.app'
+  )
+})
+
+test('resolveRemovableAppPath: dev-run .app resolves (safety is shouldRemoveAppBundle, not null)', () => {
+  // A dev run from node_modules' Electron DOES resolve to a .app — the real
+  // dev-run safety gate is shouldRemoveAppBundle(isPackaged=false,...), not a
+  // null return here. This test documents that contract.
+  assert.equal(
+    resolveRemovableAppPath('/repo/node_modules/electron/dist/Electron.app/Contents/MacOS/Electron', 'darwin'),
+    '/repo/node_modules/electron/dist/Electron.app'
+  )
+  assert.equal(shouldRemoveAppBundle(false, '/repo/node_modules/electron/dist/Electron.app'), false)
+  // A bare path with no .app ancestor → null.
+  assert.equal(resolveRemovableAppPath('/usr/bin/electron', 'darwin'), null)
+})
+
+test('resolveRemovableAppPath finds the install dir on Windows', () => {
+  assert.equal(
+    resolveRemovableAppPath('C:\\Users\\x\\AppData\\Local\\Programs\\NasTech\\NasTech.exe', 'win32'),
+    'C:\\Users\\x\\AppData\\Local\\Programs\\NasTech'
+  )
+  assert.equal(
+    resolveRemovableAppPath('C:\\Users\\x\\AppData\\Local\\nastech-desktop\\NasTech.exe', 'win32'),
+    'C:\\Users\\x\\AppData\\Local\\nastech-desktop'
+  )
+})
+
+test('resolveRemovableAppPath returns null for an unrecognized Windows dir', () => {
+  assert.equal(resolveRemovableAppPath('C:\\Temp\\foo\\NasTech.exe', 'win32'), null)
+})
+
+test('resolveRemovableAppPath uses APPIMAGE on Linux when set', () => {
+  assert.equal(
+    resolveRemovableAppPath('/tmp/.mount_NasTechXXXX/nastech', 'linux', { APPIMAGE: '/home/x/Apps/NasTech.AppImage' }),
+    '/home/x/Apps/NasTech.AppImage'
+  )
+})
+
+test('resolveRemovableAppPath finds the unpacked dir on Linux', () => {
+  assert.equal(
+    resolveRemovableAppPath('/opt/nastech/linux-unpacked/nastech', 'linux', {}),
+    '/opt/nastech/linux-unpacked'
+  )
+  // A system-package install (/usr/bin) → null, left to apt/dnf.
+  assert.equal(resolveRemovableAppPath('/usr/bin/nastech', 'linux', {}), null)
+})
+
+test('resolveRemovableAppPath returns null for an empty exe path', () => {
+  assert.equal(resolveRemovableAppPath('', 'darwin'), null)
+  assert.equal(resolveRemovableAppPath(null, 'win32'), null)
+})
+
+// --- shouldRemoveAppBundle ---
+
+test('shouldRemoveAppBundle requires packaged AND a resolved path', () => {
+  assert.equal(shouldRemoveAppBundle(true, '/Applications/NasTech.app'), true)
+  assert.equal(shouldRemoveAppBundle(false, '/Applications/NasTech.app'), false)
+  assert.equal(shouldRemoveAppBundle(true, null), false)
+  assert.equal(shouldRemoveAppBundle(false, null), false)
+})
+
+// --- buildPosixCleanupScript ---
+
+test('buildPosixCleanupScript waits for the PID, runs the uninstall module, removes bundle', () => {
+  const script = buildPosixCleanupScript({
+    desktopPid: 4321,
+    pythonExe: '/home/x/.nastech/nastech-agent/venv/bin/python',
+    pythonPath: null,
+    agentRoot: '/home/x/.nastech/nastech-agent',
+    uninstallArgs: ['-m', 'nastech_cli.uninstall', '--mode', 'gui'],
+    appPath: '/opt/nastech/linux-unpacked',
+    nastechHome: '/home/x/.nastech'
+  })
+  assert.match(script, /^#!\/bin\/bash/)
+  assert.match(script, /pid=4321/)
+  assert.match(script, /kill -0 "\$pid"/)
+  // bounded wait (~30s), not unbounded
+  assert.match(script, /seq 1 60/)
+  assert.match(script, /'-m' 'nastech_cli\.uninstall' '--mode' 'gui'/)
+  assert.match(script, /rm -rf '\/opt\/nastech\/linux-unpacked'/)
+  assert.match(script, /export NASTECH_HOME='\/home\/x\/\.nastech'/)
+})
+
+test('buildPosixCleanupScript exports PYTHONPATH when pythonPath is set (lite/full)', () => {
+  const script = buildPosixCleanupScript({
+    desktopPid: 1,
+    pythonExe: '/usr/bin/python3',
+    pythonPath: '/home/x/.nastech/nastech-agent',
+    agentRoot: '/home/x/.nastech/nastech-agent',
+    uninstallArgs: ['-m', 'nastech_cli.uninstall', '--mode', 'full'],
+    appPath: null,
+    nastechHome: '/home/x/.nastech'
+  })
+  // System python + source on PYTHONPATH so import nastech_cli works while the
+  // venv is torn down.
+  assert.match(script, /export PYTHONPATH='\/home\/x\/\.nastech\/nastech-agent'/)
+  assert.match(script, /'\/usr\/bin\/python3' '-m' 'nastech_cli\.uninstall' '--mode' 'full'/)
+})
+
+test('buildPosixCleanupScript omits PYTHONPATH when pythonPath is null (gui)', () => {
+  const script = buildPosixCleanupScript({
+    desktopPid: 1,
+    pythonExe: '/p/python',
+    pythonPath: null,
+    agentRoot: '/a',
+    uninstallArgs: ['-m', 'nastech_cli.uninstall', '--mode', 'gui'],
+    appPath: null,
+    nastechHome: '/h'
+  })
+  assert.doesNotMatch(script, /export PYTHONPATH/)
+})
+
+test('buildPosixCleanupScript omits the bundle rm when appPath is null', () => {
+  const script = buildPosixCleanupScript({
+    desktopPid: 1,
+    pythonExe: '/p/python',
+    pythonPath: null,
+    agentRoot: '/a',
+    uninstallArgs: ['-m', 'nastech_cli.uninstall', '--mode', 'lite'],
+    appPath: null,
+    nastechHome: '/h'
+  })
+  assert.doesNotMatch(script, /rm -rf '\//)
+  // Still runs the uninstall.
+  assert.match(script, /'-m' 'nastech_cli\.uninstall' '--mode' 'lite'/)
+})
+
+test('buildPosixCleanupScript single-quote-escapes paths with apostrophes', () => {
+  const script = buildPosixCleanupScript({
+    desktopPid: 1,
+    pythonExe: "/home/o'brien/python",
+    pythonPath: null,
+    agentRoot: '/a',
+    uninstallArgs: ['-m', 'nastech_cli.uninstall', '--mode', 'gui'],
+    appPath: null,
+    nastechHome: '/h'
+  })
+  // The apostrophe is closed-escaped-reopened so the shell sees the literal.
+  assert.match(script, /'\/home\/o'\\''brien\/python'/)
+})
+
+// --- buildWindowsCleanupScript ---
+
+test('buildWindowsCleanupScript waits (bounded) for PID, runs uninstall, rmdir bundle', () => {
+  const script = buildWindowsCleanupScript({
+    desktopPid: 9988,
+    pythonExe: 'C:\\Python313\\python.exe',
+    pythonPath: 'C:\\nastech',
+    agentRoot: 'C:\\nastech',
+    uninstallArgs: ['-m', 'nastech_cli.uninstall', '--mode', 'full'],
+    appPath: 'C:\\Users\\x\\AppData\\Local\\Programs\\NasTech',
+    nastechHome: 'C:\\Users\\x\\AppData\\Local\\nastech'
+  })
+  assert.match(script, /@echo off/)
+  assert.match(script, /set "PID=9988"/)
+  // PYTHONPATH set so a system python can import nastech_cli from source.
+  assert.match(script, /set "PYTHONPATH=C:\\nastech;%PYTHONPATH%"/)
+  assert.match(script, /"C:\\Python313\\python.exe" "-m" "nastech_cli\.uninstall" "--mode" "full"/)
+  // Bounded wait-loop (no infinite loop), whole-token PID match (no substring).
+  assert.match(script, /if %waited% geq 60 goto waited_done/)
+  assert.match(script, /findstr \/r \/c:" %PID% "/)
+  assert.doesNotMatch(script, /find "%PID%"/) // the old substring-prone form is gone
+  // Removal is a retry loop (Windows releases dir handles lazily).
+  assert.match(script, /:rmloop/)
+  assert.match(script, /rmdir \/s \/q "C:\\Users\\x\\AppData\\Local\\Programs\\NasTech" >nul 2>&1/)
+  assert.match(script, /if %tries% geq 10 goto rmdone/)
+  assert.match(script, /del "%~f0"/)
+})
+
+test('buildWindowsCleanupScript omits PYTHONPATH + rmdir when not needed (gui, no bundle)', () => {
+  const script = buildWindowsCleanupScript({
+    desktopPid: 2,
+    pythonExe: 'C:\\h\\venv\\Scripts\\python.exe',
+    pythonPath: null,
+    agentRoot: 'C:\\h',
+    uninstallArgs: ['-m', 'nastech_cli.uninstall', '--mode', 'gui'],
+    appPath: null,
+    nastechHome: 'C:\\h'
+  })
+  assert.doesNotMatch(script, /rmdir/)
+  assert.doesNotMatch(script, /set "PYTHONPATH=/)
+})

package/electron/entitlements.mac.inherit.plist

@@ -0,0 +1,14 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>com.apple.security.cs.allow-jit</key>
+  <true/>
+  <key>com.apple.security.cs.allow-unsigned-executable-memory</key>
+  <true/>
+  <key>com.apple.security.cs.disable-library-validation</key>
+  <true/>
+  <key>com.apple.security.device.audio-input</key>
+  <true/>
+</dict>
+</plist>

package/electron/entitlements.mac.plist

@@ -0,0 +1,14 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>com.apple.security.cs.allow-jit</key>
+  <true/>
+  <key>com.apple.security.cs.allow-unsigned-executable-memory</key>
+  <true/>
+  <key>com.apple.security.cs.disable-library-validation</key>
+  <true/>
+  <key>com.apple.security.device.audio-input</key>
+  <true/>
+</dict>
+</plist>

package/electron/fs-read-dir.cjs

@@ -0,0 +1,109 @@
+'use strict'
+
+const fs = require('node:fs')
+const path = require('node:path')
+const { resolveDirectoryForIpc } = require('./hardening.cjs')
+
+const FS_READDIR_STAT_CONCURRENCY = 16
+
+// Always-hidden noise (covers non-git projects too; gitignore catches many of
+// these, but the project tree should keep the same hygiene without one).
+const FS_READDIR_HIDDEN = new Set([
+  '.git',
+  '.hg',
+  '.svn',
+  '.cache',
+  '.next',
+  '.turbo',
+  '.venv',
+  '__pycache__',
+  'build',
+  'dist',
+  'node_modules',
+  'target',
+  'venv'
+])
+
+function direntIsDirectory(dirent) {
+  return typeof dirent.isDirectory === 'function' && dirent.isDirectory()
+}
+
+function direntIsFile(dirent) {
+  return typeof dirent.isFile === 'function' && dirent.isFile()
+}
+
+function direntIsSymbolicLink(dirent) {
+  return typeof dirent.isSymbolicLink === 'function' && dirent.isSymbolicLink()
+}
+
+function shouldStatDirent(dirent) {
+  if (direntIsDirectory(dirent)) return false
+
+  return direntIsSymbolicLink(dirent) || !direntIsFile(dirent)
+}
+
+async function entryForDirent(dirent, resolved, fsImpl) {
+  const fullPath = path.join(resolved, dirent.name)
+  let isDirectory = direntIsDirectory(dirent)
+
+  if (!isDirectory && shouldStatDirent(dirent)) {
+    try {
+      isDirectory = (await fsImpl.promises.stat(fullPath)).isDirectory()
+    } catch {
+      isDirectory = false
+    }
+  }
+
+  return { name: dirent.name, path: fullPath, isDirectory }
+}
+
+async function mapWithStatConcurrency(items, mapper) {
+  const results = new Array(items.length)
+  let nextIndex = 0
+
+  async function runWorker() {
+    while (nextIndex < items.length) {
+      const index = nextIndex
+      nextIndex += 1
+      results[index] = await mapper(items[index])
+    }
+  }
+
+  const workerCount = Math.min(FS_READDIR_STAT_CONCURRENCY, items.length)
+  const workers = Array.from({ length: workerCount }, () => runWorker())
+  await Promise.all(workers)
+
+  return results
+}
+
+async function readDirForIpc(dirPath, options = {}) {
+  const fsImpl = options.fs || fs
+  let resolved
+
+  try {
+    ;({ resolvedPath: resolved } = await resolveDirectoryForIpc(dirPath, {
+      fs: fsImpl,
+      purpose: 'Directory read'
+    }))
+  } catch (error) {
+    return { entries: [], error: error?.code || 'read-error' }
+  }
+
+  try {
+    const dirents = await fsImpl.promises.readdir(resolved, { withFileTypes: true })
+    const visibleDirents = dirents.filter(dirent => !FS_READDIR_HIDDEN.has(dirent.name))
+    const entries = await mapWithStatConcurrency(visibleDirents, dirent =>
+      entryForDirent(dirent, resolved, fsImpl)
+    )
+
+    entries.sort((a, b) => Number(b.isDirectory) - Number(a.isDirectory) || a.name.localeCompare(b.name))
+
+    return { entries }
+  } catch (error) {
+    return { entries: [], error: error?.code || 'read-error' }
+  }
+}
+
+module.exports = {
+  readDirForIpc
+}