acrylblends 1.1.0 → 1.3.0

package/plugins/desktop/main.ts

@@ -1,6 +1,8 @@
 /**
- * The desktop shell: `npm run desktop` starts the app's own server in this Electron main process and opens one window on its address. Nothing in the app
- * imports electron; every Electron call of the app is in this file and `window.ts`, so a different shell is a change here only.
+ * The desktop shell: `npm run desktop` opens the app in a window. A frame app (`scripts/ide-host.mjs`) gets the whole ACRYL frame: the window attaches to the
+ * frame host that runs for this folder, or starts it as `npm run dev` does (`frame.ts`, docs/plans/ide-host-inversion.md section 27). An app made before the frame
+ * starts its own server in this Electron main process and opens one window on its address. Nothing in the app imports electron; every Electron call of the app
+ * is in this file and `window.ts`, so a different shell is a change here only.
  *
  * Order matters: the user-data folder is set before anything else (and before the single-instance lock), so one app never shares window state, logs or the lock with
  * another app or with the real user's data.
@@ -20,10 +22,20 @@ import {
   startDoorShell,
   type WindowPort,
 } from './door-shell.ts'
+import {
+  type FrameHost,
+  frameHome,
+  isFrameApp,
+  navigation,
+  openFrameSettings,
+  runningFrame,
+  startFrameHost,
+  withoutToken,
+} from './frame.ts'
 import { hasSettings, settingsPlacement } from './menu.ts'
 import { createDesktopShutdown, installShutdownRequests } from './shutdown.ts'
 import { resolveDesktopUserDataOverride } from './user-data.ts'
-import { cascade, windowOptions } from './window.ts'
+import { cascade, windowOptions, windowSize } from './window.ts'
 
 const projectRoot = fileURLToPath(new URL('../..', import.meta.url))
 const chosen = selectInstance({ projectRoot, env: process.env })
@@ -47,6 +59,7 @@ if (!app.requestSingleInstanceLock()) {
   app.quit()
 } else {
   let running: App | undefined
+  let host: FrameHost | undefined
   let window: BrowserWindow | undefined
   let stopDoorShell: (() => void) | undefined
 
@@ -54,6 +67,8 @@ if (!app.requestSingleInstanceLock()) {
     async () => {
       stopDoorShell?.()
       await running?.stop()
+      // The frame host this window started (never one it attached to) goes with the window, with every terminal it runs.
+      await host?.stop()
     },
     (code) => {
       app.exit(code)
@@ -77,9 +92,33 @@ if (!app.requestSingleInstanceLock()) {
     // The hook above is registered before the app's modules are loaded, so the app may have .tsx pages: they are loaded here, not as a static import.
     // A dev server is already running from this folder (`npm run dev`): the door allows one process per folder, so the window opens on that server instead of starting a second one,
     // and closing the window leaves it running.
-    const attached = await runningApp(projectRoot)
+    const frame = isFrameApp(projectRoot)
+    const attached = frame ? undefined : await runningApp(projectRoot)
     let url: string
-    if (attached !== undefined) {
+    if (frame) {
+      // The frame that already runs for this folder (`npm run dev`, or another window's host), else a host of this window's own.
+      const runningAddress = await runningFrame(frameHome(projectRoot, process.env))
+      if (runningAddress !== undefined) {
+        console.log(
+          `desktop: attached to the frame already running from this folder at ${new URL(runningAddress).origin} (it keeps running when the window closes)`,
+        )
+        url = runningAddress
+      } else {
+        host = startFrameHost(projectRoot, process.env, (text) => {
+          process.stdout.write(text)
+        })
+        try {
+          url = await host.ready
+        } catch (cause) {
+          console.error(`desktop: ${cause instanceof Error ? cause.message : String(cause)}`)
+          await shutdown.request(1)
+          return
+        }
+        console.log(
+          `desktop: the frame host serves ${new URL(url).origin}; closing the window stops it`,
+        )
+      }
+    } else if (attached !== undefined) {
       console.log(
         `desktop: attached to the app already running from this folder at ${attached.url} (its server keeps running when the window closes)`,
       )
@@ -90,14 +129,23 @@ if (!app.requestSingleInstanceLock()) {
       url = running.url
     }
     const origin = new URL(url).origin
-    /** One window on a path of the app. Navigation stays on the app's own server; any other address opens in the system browser. The user agent names the window to the door (`AcrylWindow/<id>`), so an agent can drive it with `--window <id>`. */
+    /** Where a window opens: the frame's address (with its token) for a frame app, else a path of the app (`acrylblends.desktopPath`, else the root). */
+    const addressOf = (path: string | undefined): string =>
+      frame && path === undefined ? url : new URL(path ?? startPath(), url).href
+    /** One window on an address of the app. Navigation follows `navigation` in frame.ts. The user agent names the window to the door (`AcrylWindow/<id>`), so an agent can drive it with `--window <id>`. */
     // Where each window was opened: `window list` shows it until the page reports its own address (Electron gives none while the first load has not started).
     const openedOn = new Map<number, string>()
-    const createWindow = (path: string): BrowserWindow => {
+    const createWindow = (path: string | undefined): BrowserWindow => {
       // A window opened while another is open sits a step down and to the right of it, not exactly on top.
       const beside =
         BrowserWindow.getFocusedWindow() ??
         BrowserWindow.getAllWindows().find((other) => !other.isDestroyed())
+      const work = (
+        beside === undefined
+          ? screen.getPrimaryDisplay()
+          : screen.getDisplayMatching(beside.getBounds())
+      ).workArea
+      const size = windowSize(work)
       const where = (() => {
         if (beside === undefined) return {}
         const bounds = beside.getBounds()
@@ -106,44 +154,49 @@ if (!app.requestSingleInstanceLock()) {
           .filter((other) => !other.isDestroyed())
           .map((other) => other.getPosition())
           .map(([x = 0, y = 0]) => ({ x, y }))
-        return cascade(
-          bounds,
-          screen.getDisplayMatching(bounds).workArea,
-          { width: 1100, height: 760 },
-          taken,
-        )
+        return cascade(bounds, work, size, taken)
       })()
-      const created = new BrowserWindow(windowOptions({ title: chosen.name, ...where }))
-      openedOn.set(created.id, path)
+      const created = new BrowserWindow(windowOptions({ title: chosen.name, ...size, ...where }))
+      const address = addressOf(path)
+      openedOn.set(created.id, new URL(address).pathname)
       created.webContents.setUserAgent(
         `${created.webContents.getUserAgent()} AcrylWindow/${String(created.id)}`,
       )
       created.once('ready-to-show', () => created.show())
-      created.webContents.setWindowOpenHandler(({ url }) => {
-        void shell.openExternal(url)
+      // A new window of the page never opens inside the app: an http(s) or mailto address goes to the system browser, anything else nowhere.
+      created.webContents.setWindowOpenHandler(({ url: target }) => {
+        if (navigation(target, '') === 'external') void shell.openExternal(target)
         return { action: 'deny' }
       })
-      created.webContents.on('will-navigate', (event, url) => {
-        if (new URL(url).origin === origin) return
+      // Only the main frame is checked, so the frame's tiles (the app's page in an iframe) navigate freely; the window itself stays on the app's origin.
+      created.webContents.on('will-frame-navigate', (event) => {
+        const decision = navigation(event.url, origin, event.isMainFrame)
+        if (decision === 'stay') return
         event.preventDefault()
-        void shell.openExternal(url)
+        if (decision === 'external') void shell.openExternal(event.url)
+      })
+      created.webContents.on('will-redirect', (event, target, _inPlace, isMainFrame) => {
+        if (navigation(target, origin, isMainFrame) !== 'stay') event.preventDefault()
       })
-      created.loadURL(new URL(path, url).href).catch((cause: unknown) => {
+      created.loadURL(address).catch((cause: unknown) => {
         console.warn(
-          `desktop: the window could not load ${path}: ${cause instanceof Error ? cause.message : String(cause)}`,
+          `desktop: the window could not load ${new URL(address).pathname}: ${cause instanceof Error ? cause.message : String(cause)}`,
         )
       })
       return created
     }
-    window = createWindow(startPath())
+    window = createWindow(frame ? undefined : startPath())
     // The door (development) reaches the windows and the menu through this port: `acryl window list`, `acryl menu click`.
     const live = (): BrowserWindow[] =>
       BrowserWindow.getAllWindows().filter((candidate) => !candidate.isDestroyed())
     const port = (candidate: BrowserWindow): WindowPort => ({
       id: candidate.id,
       getTitle: () => candidate.getTitle(),
+      // Without the frame's launch token: the door prints this address and its audit keeps it.
       getURL: () =>
-        candidate.webContents.getURL() || new URL(openedOn.get(candidate.id) ?? '/', url).href,
+        withoutToken(
+          candidate.webContents.getURL() || new URL(openedOn.get(candidate.id) ?? '/', url).href,
+        ),
       isFocused: () => candidate.isFocused(),
       isMinimized: () => candidate.isMinimized(),
       getSize: () => candidate.getSize(),
@@ -169,17 +222,20 @@ if (!app.requestSingleInstanceLock()) {
     })
     const desktop: DesktopPort = {
       windows: () => live().map(port),
-      open: (path) => port(createWindow(path ?? startPath())),
+      open: (path) => port(createWindow(path ?? (frame ? undefined : startPath()))),
       menu: () => (Menu.getApplicationMenu()?.items ?? []).map(menuItem),
     }
     // An app that serves a /settings page gets a Settings item in the menu (Electron's own menu otherwise): it opens that page, in the window that already shows it when there is one.
-    const settingsServed = await fetch(new URL('/settings', url), {
-      headers: { accept: 'text/html' },
-      signal: AbortSignal.timeout(2000),
-    }).then(
-      (answer) => answer.ok,
-      () => false,
-    )
+    // A frame window's item opens the frame's own Settings (the dialog the left panel's button opens), in the window that has focus.
+    const settingsServed = frame
+      ? true
+      : await fetch(new URL('/settings', url), {
+          headers: { accept: 'text/html' },
+          signal: AbortSignal.timeout(2000),
+        }).then(
+          (answer) => answer.ok,
+          () => false,
+        )
     const menu = Menu.getApplicationMenu()
     const placement =
       menu === null || !settingsServed || hasSettings(menu.items)
@@ -188,6 +244,18 @@ if (!app.requestSingleInstanceLock()) {
     if (menu !== null && placement !== undefined) {
       const target = menu.items[placement.menu]?.submenu
       const openSettings = (): void => {
+        if (frame) {
+          const target = BrowserWindow.getFocusedWindow() ?? live()[0]
+          if (target === undefined) return
+          if (target.isMinimized()) target.restore()
+          target.focus()
+          target.webContents.executeJavaScript(openFrameSettings).catch((cause: unknown) => {
+            console.warn(
+              `desktop: Settings could not be opened in the frame: ${cause instanceof Error ? cause.message : String(cause)}`,
+            )
+          })
+          return
+        }
         const shown = live().find(
           (candidate) =>
             new URL(candidate.webContents.getURL() || 'about:blank', url).pathname === '/settings',

package/plugins/desktop/window.ts

@@ -19,6 +19,23 @@ export interface Rect {
 /** How far each new window sits from the one it was opened from. */
 export const CASCADE_STEP = 32
 
+/** A window's size when nothing asks for another, and the smallest it may be. */
+export const WINDOW_SIZE = { width: 1100, height: 760 } as const
+export const WINDOW_MIN_SIZE = { width: 480, height: 360 } as const
+
+/**
+ * The size of a new window on a work area: the usual size, made smaller on a screen where it would not leave room for a few cascade steps, never below the
+ * smallest size. macOS moves a window that runs past the screen's edge back onto it, so on a small screen (CI's 1024x768) a window of the usual size that
+ * `cascade` placed a step from another lands exactly on it; a window of this size fits at its place.
+ */
+export function windowSize(work: Rect): { width: number; height: number } {
+  const room = CASCADE_STEP * 3
+  return {
+    width: Math.max(WINDOW_MIN_SIZE.width, Math.min(WINDOW_SIZE.width, work.width - room)),
+    height: Math.max(WINDOW_MIN_SIZE.height, Math.min(WINDOW_SIZE.height, work.height - room)),
+  }
+}
+
 /**
  * Where a new window goes so that it does not cover another one exactly. The first free place of: a step down and to the right of `from`, and again, while the window still fits on the
  * screen; then the same steps from the top left of the work area (a row of windows cascades, then starts again); and, on a screen no bigger than the window, the steps from `from` even
@@ -73,10 +90,10 @@ export interface WindowOptions {
 export function windowOptions(spec: WindowSpec): WindowOptions {
   return {
     title: spec.title,
-    width: spec.width ?? 1100,
-    height: spec.height ?? 760,
-    minWidth: 480,
-    minHeight: 360,
+    width: spec.width ?? WINDOW_SIZE.width,
+    height: spec.height ?? WINDOW_SIZE.height,
+    minWidth: WINDOW_MIN_SIZE.width,
+    minHeight: WINDOW_MIN_SIZE.height,
     ...(spec.x === undefined || spec.y === undefined ? {} : { x: spec.x, y: spec.y }),
     show: false,
     webPreferences: {

package/plugins/driver-pty/client/terminal.ts

@@ -4,7 +4,7 @@ import { FitAddon } from './vendor/addon-fit.mjs'
 import { Terminal } from './vendor/xterm.mjs'
 import css from './vendor/xterm-css.mjs'
 
-const PREFIX = '/api/driver-pty'
+let PREFIX = '/api/driver-pty'
 const REMEMBERED = 'driver-pty-session'
 
 export interface TerminalView {
@@ -21,6 +21,8 @@ interface Options {
   token: string
   /** The terminal driver's name (`pty:claude`). */
   driver: string
+  /** The URL prefix the driver's endpoints live under (`/api/driver-pty`, or the app's mount followed by it). */
+  prefix: string
   /** Called with a line of status for the panel to show (`The terminal ended (exit 0).`). */
   status(text: string): void
   /** A plugin was installed or removed while the terminal was open. */
@@ -57,6 +59,7 @@ async function* frames(response: Response): AsyncGenerator<Frame> {
 
 export async function openTerminal(options: Options): Promise<TerminalView> {
   const { container, token, driver, status, onChange } = options
+  PREFIX = options.prefix
   const headers = { 'content-type': 'application/json', 'x-agent-panel-token': token }
   const call = (path: string, body: unknown = {}): Promise<Response> =>
     fetch(`${PREFIX}${path}`, { method: 'POST', headers, body: JSON.stringify(body) })

package/plugins/driver-pty/index.ts

@@ -5,6 +5,8 @@
  * - The drivers are `terminal` entries of the panel's `drivers` service (`pty:claude`, ...). A panel without this plugin lists none; this plugin without a panel is pending.
  * - Transport is server-sent events down and POST up (no WebSocket): `POST /api/driver-pty/sessions`, `GET /api/driver-pty/<id>/output` (events with ids; a reconnect replays
  *   from `Last-Event-ID`, from a ring buffer of at least 64 KB), `POST .../input`, `.../resize`, `.../stop`. Same origin check and token as the panel, development only.
+ * - The routes live under the app's mount, like the panel's: `/api/driver-pty` on the app's own server, `<mount>/api/driver-pty` when a host serves the app at a prefix
+ *   (the frame's `/app`). The row's `mount` config names it, and each driver carries its view (`view: { module, prefix }`) so the panel calls the mounted paths.
  * - Every process is acquired inside one `ctx.effect`; its disposer ends the process (group), closes the streams and writes the audit line. Unloading or reloading the
  *   plugin with a session open leaves no process behind.
  */
@@ -16,8 +18,9 @@ import { streamSSE } from '../acryl-router/src/helpers/index.ts'
 import { Acryl } from '../acryl-router/src/index.ts'
 import type { TerminalDriver, TerminalSession } from '../agent-panel/drivers.ts'
 import { onPath } from '../agent-panel/headless.ts'
+import { mountedBase, mountedPrefix } from '../agent-panel/mount.ts'
 import type {} from '../agent-panel/registry.ts'
-import { loadNodePty, type PtySpawn } from './spawn.ts'
+import { loadNodePty, type PtySpawn, resolveProgram } from './spawn.ts'
 import { terminalDriver } from './terminal.ts'
 
 export const name = 'driver-pty'
@@ -26,7 +29,7 @@ export const inject = ['drivers', 'router', 'appInstance']
 export type { PtyProcess, PtySpawn } from './spawn.ts'
 export { terminalDriver } from './terminal.ts'
 
-const PREFIX = '/api/driver-pty'
+const DRIVER_PATH = '/api/driver-pty'
 const CLIENT_DIR = join(import.meta.dirname, 'client')
 /** The least output a reconnecting page can be given again. */
 const SCROLLBACK = 64 * 1024
@@ -36,6 +39,11 @@ export interface DriverPtyConfig {
   programs?: Record<string, string[]>
   /** The PTY implementation; default node-pty. Tests give a fake. */
   spawn?: PtySpawn
+  /**
+   * The URL prefix the app is mounted at: empty on the app's own server, `/app` when the ACRYL frame hosts it (the same `mount` the panel takes). The
+   * terminal's routes and its browser view live under it, so the terminal belongs to the app and is served wherever the app is.
+   */
+  mount?: string
 }
 
 interface Chunk {
@@ -61,6 +69,9 @@ interface Live {
 
 export async function apply(ctx: Context, config: DriverPtyConfig = {}): Promise<void> {
   if (process.env.NODE_ENV === 'production' || process.env.ACRYL_DOOR === 'off') return
+  const PREFIX = mountedPrefix(config.mount, DRIVER_PATH, 'driver-pty')
+  // The routes mount at the app's own mount and keep the fixed driver path inside (the frame's router prefixes the mount, not the routes).
+  const MOUNT = mountedBase(config.mount, 'driver-pty')
   const root = ctx.appInstance.root
   let spawn = config.spawn
   if (!spawn) {
@@ -80,7 +91,15 @@ export async function apply(ctx: Context, config: DriverPtyConfig = {}): Promise
       (['claude', 'codex', 'pi'] as const).filter(onPath).map((p) => [p, [] as string[]]),
     )
   for (const [program, args] of Object.entries(programs))
-    ctx.effect(() => ctx.drivers.register(terminalDriver(`pty:${program}`, program, args, spawn)))
+    ctx.effect(() =>
+      ctx.drivers.register(
+        // The name stays the program the app configured; the PTY runs its full path (Windows does not search PATH itself).
+        terminalDriver(`pty:${program}`, resolveProgram(program), args, spawn, {
+          module: `${PREFIX}/client/terminal.ts`,
+          prefix: PREFIX,
+        }),
+      ),
+    )
 
   const auditFile = join(root, '.acryl', 'audit', 'driver-pty.jsonl')
   const audit = (entry: Record<string, unknown>): void => {
@@ -162,8 +181,8 @@ export async function apply(ctx: Context, config: DriverPtyConfig = {}): Promise
   ctx.effect(() => off)
 
   const app = new Acryl()
-    .route(`${PREFIX}/client`, clientModules({ root: CLIENT_DIR }))
-    .post(`${PREFIX}/sessions`, async (c) => {
+    .route(`${DRIVER_PATH}/client`, clientModules({ root: CLIENT_DIR, mount: `${PREFIX}/client` }))
+    .post(`${DRIVER_PATH}/sessions`, async (c) => {
       if (!ctx.drivers.authorized(c.req.raw.headers)) return refuse(c)
       const body = (await c.req.json().catch(() => ({}))) as {
         driver?: unknown
@@ -177,10 +196,18 @@ export async function apply(ctx: Context, config: DriverPtyConfig = {}): Promise
         return c.json({ error: 'a terminal is already open; stop it first' }, 409)
       const num = (value: unknown, fallback: number) =>
         typeof value === 'number' && value >= 1 && value <= 1000 ? Math.floor(value) : fallback
-      live = startSession(driver, num(body.cols, 80), num(body.rows, 24))
+      let session: Live
+      try {
+        session = startSession(driver, num(body.cols, 80), num(body.rows, 24))
+      } catch (error) {
+        // The cause (a native module that cannot spawn, a program that is gone) goes to the app's log; the page gets a plain answer, as everywhere else.
+        console.error('driver-pty: the terminal could not start:', error)
+        return c.json({ error: 'the terminal could not start; the app log has the reason' }, 500)
+      }
+      live = session
       return c.json({ id: live.id })
     })
-    .get(`${PREFIX}/:id/output`, (c) => {
+    .get(`${DRIVER_PATH}/:id/output`, (c) => {
       if (!ctx.drivers.authorized(c.req.raw.headers)) return refuse(c)
       const current = find(c.req.param('id'))
       if (!current) return c.json({ error: 'no such terminal' }, 404)
@@ -216,7 +243,7 @@ export async function apply(ctx: Context, config: DriverPtyConfig = {}): Promise
         })
       })
     })
-    .post(`${PREFIX}/:id/input`, async (c) => {
+    .post(`${DRIVER_PATH}/:id/input`, async (c) => {
       if (!ctx.drivers.authorized(c.req.raw.headers)) return refuse(c)
       const current = find(c.req.param('id'))
       if (!current || current.exit) return c.json({ error: 'no such terminal' }, 404)
@@ -226,7 +253,7 @@ export async function apply(ctx: Context, config: DriverPtyConfig = {}): Promise
       current.session.write(data)
       return c.json({ ok: true })
     })
-    .post(`${PREFIX}/:id/resize`, async (c) => {
+    .post(`${DRIVER_PATH}/:id/resize`, async (c) => {
       if (!ctx.drivers.authorized(c.req.raw.headers)) return refuse(c)
       const current = find(c.req.param('id'))
       if (!current || current.exit) return c.json({ error: 'no such terminal' }, 404)
@@ -239,12 +266,12 @@ export async function apply(ctx: Context, config: DriverPtyConfig = {}): Promise
       current.session.resize(cols, rows)
       return c.json({ ok: true })
     })
-    .post(`${PREFIX}/:id/stop`, async (c) => {
+    .post(`${DRIVER_PATH}/:id/stop`, async (c) => {
       if (!ctx.drivers.authorized(c.req.raw.headers)) return refuse(c)
       const current = find(c.req.param('id'))
       if (!current) return c.json({ error: 'no such terminal' }, 404)
       await current.dispose()
       return c.json({ ok: true })
     })
-  ctx.router.route('/', app)
+  ctx.router.route(MOUNT === '' ? '/' : MOUNT, app)
 }

package/plugins/driver-pty/spawn.ts

@@ -1,4 +1,6 @@
 /** The one place that touches `node-pty`, a native module. Everything else works on this small seam, so tests run on a fake process. */
+import { statSync } from 'node:fs'
+import { delimiter, join } from 'node:path'
 
 export interface PtyProcess {
   readonly pid: number
@@ -16,6 +18,42 @@ export type PtySpawn = (
   options: { cwd: string; env: NodeJS.ProcessEnv; cols: number; rows: number },
 ) => PtyProcess
 
+/**
+ * The file a terminal runs: a full path. On Windows node-pty runs the file as it is given and does not search PATH - a bare `node` is "File not found" - so
+ * a bare program name is looked up once, with the platform's PATH separator and, on Windows, PATHEXT. A name that is not found comes back unchanged, and
+ * the start fails with the PTY's own error.
+ */
+export function resolveProgram(
+  program: string,
+  env: NodeJS.ProcessEnv = process.env,
+  platform: NodeJS.Platform = process.platform,
+): string {
+  if (program === '' || program.includes('/') || (platform === 'win32' && program.includes('\\')))
+    return program
+  const windows = platform === 'win32'
+  const folders = (env.PATH ?? env.Path ?? '').split(windows ? ';' : delimiter)
+  const lower = program.toLowerCase()
+  const known = (env.PATHEXT ?? '.COM;.EXE;.BAT;.CMD').split(';').filter(Boolean)
+  const suffixes = !windows
+    ? ['']
+    : known.some((extension) => lower.endsWith(extension.toLowerCase()))
+      ? ['']
+      : ['', ...new Set(known)]
+  for (const folder of folders) {
+    if (folder === '') continue
+    for (const suffix of suffixes) {
+      const candidate = join(folder, `${program}${suffix}`)
+      try {
+        const stat = statSync(candidate)
+        if (stat.isFile() && (windows || (stat.mode & 0o111) !== 0)) return candidate
+      } catch {
+        // Not here: the next folder, or the next extension.
+      }
+    }
+  }
+  return program
+}
+
 /** Loads node-pty. Rejects with the reason (the error and the platform), so a log says why the driver is not offered. */
 export async function loadNodePty(): Promise<PtySpawn> {
   try {

package/plugins/driver-pty/terminal.ts

@@ -22,10 +22,12 @@ export function terminalDriver(
   program: string,
   args: string[],
   spawn: PtySpawn,
+  view: TerminalDriver['view'],
 ): TerminalDriver {
   return {
     kind: 'terminal',
     name,
+    view,
     start({ cwd, env, cols, rows }): TerminalSession {
       // The agent runs `acryl look` without the folder prefix.
       const path = [join(cwd, '.acryl', 'bin'), env.PATH].filter(Boolean).join(delimiter)