acrylblends 1.3.2 → 1.5.0

package/plugins/desktop/main.ts

@@ -11,11 +11,15 @@
 import { mkdirSync, readFileSync } from 'node:fs'
 import { join } from 'node:path'
 import { fileURLToPath } from 'node:url'
-import { app, BrowserWindow, Menu, MenuItem, screen, shell } from 'electron'
+import { app, BrowserWindow, dialog, ipcMain, Menu, MenuItem, screen, shell } from 'electron'
 import type { App } from '../../src/app.ts'
 import '../acryl-node-server/src/register.ts'
-import { selectInstance } from '../instance/index.ts'
+import { readProduct } from '../instance/bundle.ts'
+import { type AppInstance, instanceEnv, selectInstance, withRunEnv } from '../instance/index.ts'
+import { type AppStorage, openProductStorage } from '../instance/storage.ts'
+import { APP_PAGE_CHANNEL, appPageHandler } from './app-page.ts'
 import { runningApp } from './attach.ts'
+import { appTitle, iconFile } from './brand.ts'
 import {
   type DesktopPort,
   type MenuItemPort,
@@ -24,7 +28,7 @@ import {
 } from './door-shell.ts'
 import {
   type FrameHost,
-  frameHome,
+  type HostEnd,
   isFrameApp,
   navigation,
   openFrameSettings,
@@ -32,13 +36,55 @@ import {
   startFrameHost,
   withoutToken,
 } from './frame.ts'
+import { productGit, withGitFirst } from './git.ts'
+import { appendHostLog, hostCrashed, nextRestart } from './host-supervisor.ts'
 import { hasSettings, settingsPlacement } from './menu.ts'
+import { openProductApp, seedSource } from './product.ts'
 import { createDesktopShutdown, installShutdownRequests } from './shutdown.ts'
 import { resolveDesktopUserDataOverride } from './user-data.ts'
 import { cascade, windowOptions, windowSize } from './window.ts'
 
-const projectRoot = fileURLToPath(new URL('../..', import.meta.url))
-const chosen = selectInstance({ projectRoot, env: process.env })
+/** The app shipped inside the bundle (a packaged product) or checked out by the person (an app made with `acrylblends init`). */
+const bundledRoot = fileURLToPath(new URL('../..', import.meta.url))
+// A product build keeps its apps in its own root in the OS per-user data folder, one sealed folder each, and runs on the source of the one it opens: the
+// bundle is the read-only Program (plugins/instance/storage.ts). An app made with `acrylblends init` runs on its own folder.
+const product = app.isPackaged ? readProduct(bundledRoot) : undefined
+/** The git the product ships beside the app (Resources/git), first on the frame host's PATH; the person's own git otherwise. */
+const git = product === undefined ? undefined : productGit(process.resourcesPath, process.platform)
+let storage: AppStorage | undefined
+/** The app the window shows. A product can switch to another of its apps (Settings > App: import, start over, open). */
+let chosen: AppInstance
+try {
+  storage =
+    product === undefined
+      ? undefined
+      : openProductStorage({
+          writtenBy: app.getVersion(),
+          ...(git === undefined ? {} : { git: git.executable }),
+          reveal: (path) => {
+            shell.showItemInFolder(path)
+          },
+        })
+  chosen =
+    storage === undefined || product === undefined
+      ? selectInstance({ projectRoot: bundledRoot, env: process.env })
+      : withRunEnv(openProductApp(storage, product, bundledRoot), process.env)
+} catch (cause) {
+  // A root of a newer version, or one this version cannot read: said once, in a dialog, and nothing is started or written.
+  const message = cause instanceof Error ? cause.message : String(cause)
+  console.error(`desktop: ${message}`)
+  dialog.showErrorBox(`${product?.product ?? 'The app'} cannot open`, message)
+  app.exit(1)
+  throw cause
+}
+const projectRoot = chosen.root
+/** Where the Program is: the bundle of a product (its apps' sources hold only the person's files), else the app folder itself. */
+const programRoot = storage === undefined ? projectRoot : bundledRoot
+if (git !== undefined)
+  app.setAboutPanelOptions({
+    credits:
+      'Includes Git, free software under the GNU GPL version 2. Its licence and the offer of its source are in Settings > App.',
+  })
 
 /** Where the window opens: `acrylblends.desktopPath` in package.json (the todo template sets `/todo`), else the root. */
 function startPath(): string {
@@ -48,11 +94,12 @@ function startPath(): string {
   return manifest.acrylblends?.desktopPath ?? '/'
 }
 
-/** Electron's user-data folder: an explicit DSH_DESKTOP_USER_DATA, else a folder inside the app's own home. */
-const userData = resolveDesktopUserDataOverride(process.env) ?? join(chosen.home, 'electron')
+/** Electron's user-data folder: an explicit DSH_DESKTOP_USER_DATA, else the product's own (beside its apps), else a folder inside the app's own home. */
+const userData =
+  resolveDesktopUserDataOverride(process.env) ?? storage?.electron ?? join(chosen.home, 'electron')
 mkdirSync(userData, { recursive: true, mode: 0o700 })
 app.setPath('userData', userData)
-app.setName(chosen.name)
+app.setName(appTitle(projectRoot))
 
 if (!app.requestSingleInstanceLock()) {
   // The same app is already open: its window takes focus (see `second-instance` below) and this process ends.
@@ -89,26 +136,120 @@ if (!app.requestSingleInstanceLock()) {
   })
 
   void app.whenReady().then(async () => {
+    // The Dock shows the app's own icon even when the bundle could not be branded (brand.ts); a no-op where there is no Dock.
+    app.dock?.setIcon(iconFile(projectRoot))
     // 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 frame = isFrameApp(projectRoot)
+    const frame = isFrameApp(programRoot)
     const attached = frame ? undefined : await runningApp(projectRoot)
     let url: string
+    /** This window's own frame host on the chosen app; its address once it serves. */
+    const startHost = (): Promise<string> => {
+      // The host chooses the same home and port as this window: decided here once, never again from the folder it runs in. The product's git comes first
+      // on its PATH, so everything the host starts finds it by name.
+      const env = { ...process.env, ...instanceEnv(chosen) }
+      const logs = join(chosen.home, 'logs')
+      const started = startFrameHost(
+        chosen.root,
+        git === undefined ? env : withGitFirst(env, git, process.platform),
+        (text) => {
+          // Kept on disk too: a packaged app has no terminal, and a host that stops must leave its reason.
+          appendHostLog(logs, text)
+          process.stdout.write(text)
+          // The watcher that runs the host stays alive when the host crashes (it waits for a saved file): that line is the death.
+          recent = (recent + text).slice(-3000)
+          if (serving && hostCrashed(text))
+            void started.stop().then(() => recover(started, crashedEnd(recent)))
+        },
+        process.platform,
+        // A packaged product carries no npm: its host runs on this app's own Electron runtime.
+        app.isPackaged ? { runtime: process.execPath, program: programRoot } : {},
+      )
+      host = started
+      let serving = false
+      let recent = ''
+      // Watched once it serves: a host that ends before that fails the start itself (the caller quits with the reason).
+      return started.ready.then((address) => {
+        serving = true
+        void started.ended.then((end) => recover(started, end))
+        return address
+      })
+    }
+    const crashedEnd = (text: string): HostEnd => ({
+      code: null,
+      signal: null,
+      tail: text,
+      requested: false,
+    })
+    /** When the host stopped by itself (it did not die with the window or a switch of app): the times, so a host that keeps stopping is given up on. */
+    const stops: number[] = []
+    /** The host this window started ended without being asked to: start it again and show it in every window, or say why not. */
+    const recover = async (first: FrameHost, end: HostEnd): Promise<void> => {
+      if (end.requested || host !== first) return
+      /** The host this loop is answering for: the one that stopped, then each attempt that did not serve. A switch of app replaces `host`, and then it is not ours any more. */
+      let ours = first
+      const logs = join(chosen.home, 'logs')
+      let last = end
+      for (;;) {
+        const exit = last.signal ?? `code ${String(last.code)}`
+        appendHostLog(logs, `\n[desktop] the frame host ended by itself (${exit})\n`)
+        console.error(`desktop: the frame host ended by itself (${exit}); ${last.tail.slice(-400)}`)
+        const decision = nextRestart(stops, Date.now())
+        if (!decision.restart) {
+          const answer = await dialog.showMessageBox({
+            type: 'error',
+            message: `${chosen.name} keeps stopping`,
+            detail: `Its engine stopped by itself ${String(stops.length)} times in two minutes (${exit}).\n\nLast output:\n${last.tail.slice(-600)}\n\nThe whole output is in ${logs}`,
+            buttons: ['Try again', 'Quit'],
+            defaultId: 0,
+            cancelId: 1,
+          })
+          if (answer.response !== 0) {
+            await shutdown.request(1)
+            return
+          }
+          stops.length = 0
+          continue
+        }
+        stops.push(Date.now())
+        await new Promise((done) => setTimeout(done, decision.delayMs))
+        if (host !== ours) return
+        try {
+          url = await startHost()
+        } catch (cause) {
+          if (host !== undefined) ours = host
+          // It ended before it served: that is another stop, with the reason it gave.
+          last = {
+            code: null,
+            signal: null,
+            tail: cause instanceof Error ? cause.message : String(cause),
+            requested: false,
+          }
+          continue
+        }
+        origin = new URL(url).origin
+        for (const shown of live())
+          shown.loadURL(url).catch((cause: unknown) => {
+            console.warn(
+              `desktop: the window could not load the restarted app: ${cause instanceof Error ? cause.message : String(cause)}`,
+            )
+          })
+        console.log(`desktop: the frame host was started again at ${origin}`)
+        return
+      }
+    }
     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))
+      const runningAddress = await runningFrame(chosen.home)
       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
+          url = await startHost()
         } catch (cause) {
           console.error(`desktop: ${cause instanceof Error ? cause.message : String(cause)}`)
           await shutdown.request(1)
@@ -128,13 +269,16 @@ if (!app.requestSingleInstanceLock()) {
       running = await createApp(chosen)
       url = running.url
     }
-    const origin = new URL(url).origin
+    // Both change when a product switches to another of its apps (each app has its own port); the handlers below read them when they run.
+    let origin = new URL(url).origin
     /** 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>()
+    /** The App pages are a product's, on a frame host this window started: a host it attached to belongs to another process. */
+    const appPage = storage !== undefined && frame && host !== undefined
     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 =
@@ -156,12 +300,25 @@ if (!app.requestSingleInstanceLock()) {
           .map(([x = 0, y = 0]) => ({ x, y }))
         return cascade(bounds, work, size, taken)
       })()
-      const created = new BrowserWindow(windowOptions({ title: chosen.name, ...size, ...where }))
+      const created = new BrowserWindow(
+        windowOptions({
+          title: chosen.name,
+          ...size,
+          ...where,
+          // A product's window page gets the bridge of its App pages (Settings > App, Name your app).
+          ...(appPage ? { preload: fileURLToPath(new URL('./preload.cjs', import.meta.url)) } : {}),
+        }),
+      )
       const address = addressOf(path)
       openedOn.set(created.id, new URL(address).pathname)
       created.webContents.setUserAgent(
         `${created.webContents.getUserAgent()} AcrylWindow/${String(created.id)}`,
       )
+      // The window is named for the app it shows (its name, and a new one after a rename), not for the page's own `<title>`: the frame's page says "ACRYL".
+      created.on('page-title-updated', (event) => {
+        event.preventDefault()
+        created.setTitle(chosen.name)
+      })
       created.once('ready-to-show', () => created.show())
       // 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 }) => {
@@ -274,6 +431,100 @@ if (!app.requestSingleInstanceLock()) {
         target?.insert(placement.at + 1, new MenuItem({ type: 'separator' }))
       Menu.setApplicationMenu(menu)
     }
-    stopDoorShell = startDoorShell(projectRoot, { desktop, log: console.log })
+    stopDoorShell = startDoorShell(chosen.root, { desktop, log: console.log })
+
+    if (appPage && storage !== undefined && product !== undefined) {
+      const productStorage = storage
+      /** Stop the host, run `next`, start the host on the app it returns and show it in every window; the app that ran comes back when `next` fails. */
+      const switchTo = async (next: () => AppInstance): Promise<void> => {
+        const previous = chosen
+        await host?.stop()
+        host = undefined
+        let failure: unknown
+        try {
+          chosen = withRunEnv(next(), process.env)
+        } catch (cause) {
+          failure = cause
+          chosen = previous
+        }
+        try {
+          url = await startHost()
+        } catch (cause) {
+          console.error(`desktop: ${cause instanceof Error ? cause.message : String(cause)}`)
+          if (chosen === previous) {
+            await shutdown.request(1)
+            return
+          }
+          // The new app does not start: the one that ran comes back, if its folders are still there.
+          failure = cause
+          chosen = previous
+          url = await startHost()
+        }
+        origin = new URL(url).origin
+        app.setName(chosen.name)
+        stopDoorShell?.()
+        stopDoorShell = startDoorShell(chosen.root, { desktop, log: console.log })
+        for (const shown of live())
+          shown.loadURL(url).catch((cause: unknown) => {
+            console.warn(
+              `desktop: the window could not load the app: ${cause instanceof Error ? cause.message : String(cause)}`,
+            )
+          })
+        console.log(`desktop: now showing the app "${chosen.name}" (${chosen.id}) at ${origin}`)
+        if (failure !== undefined) throw failure
+      }
+      const dialogParent = (): BrowserWindow | undefined =>
+        BrowserWindow.getFocusedWindow() ?? live()[0]
+      const archiveFilter = [{ name: 'ACRYL Blends app', extensions: ['acrylblend'] }]
+      const handle = appPageHandler({
+        storage: productStorage,
+        current: () => chosen.id,
+        seed: (source) => {
+          seedSource(bundledRoot, source, product.program)
+        },
+        switchTo,
+        chooseExportFile: async (suggested) => {
+          const parent = dialogParent()
+          const options = { defaultPath: suggested, filters: archiveFilter }
+          const answer = await (parent === undefined
+            ? dialog.showSaveDialog(options)
+            : dialog.showSaveDialog(parent, options))
+          return answer.canceled || answer.filePath === undefined || answer.filePath === ''
+            ? undefined
+            : answer.filePath
+        },
+        chooseImportFile: async () => {
+          const parent = dialogParent()
+          const options = { filters: archiveFilter, properties: ['openFile' as const] }
+          const answer = await (parent === undefined
+            ? dialog.showOpenDialog(options)
+            : dialog.showOpenDialog(parent, options))
+          return answer.canceled ? undefined : answer.filePaths[0]
+        },
+        openPath: async (path) => {
+          const problem = await shell.openPath(path)
+          if (problem !== '') throw new Error(problem)
+        },
+        renamed: (renamed) => {
+          chosen = Object.freeze({ ...chosen, name: renamed.name })
+          app.setName(renamed.name)
+          for (const open of BrowserWindow.getAllWindows())
+            if (!open.isDestroyed()) open.setTitle(renamed.name)
+        },
+        platform: process.platform,
+        ...(git === undefined ? {} : { git }),
+      })
+      ipcMain.handle(APP_PAGE_CHANNEL, (event, op: unknown, arg: unknown) => {
+        // Only the window's own page on the frame's origin: never the app's iframe, never a page the window was sent to.
+        const sender = event.senderFrame
+        if (
+          sender === null ||
+          sender !== event.sender.mainFrame ||
+          new URL(sender.url).origin !== origin
+        )
+          return { ok: false, message: 'only the frame page can ask this' }
+        return handle(op, arg)
+      })
+    }
   })
 }

package/plugins/desktop/preload.cjs

@@ -0,0 +1,8 @@
+// The one thing a desktop product's window page gets from the shell: `window.acrylBlendsApp.call(op, arg)`, answered by `app-page.ts` in the main process
+// (the frame's App pages: name, size, show, export, import, start over). A sandboxed preload is a CommonJS script and can only require electron; the
+// channel name is `APP_PAGE_CHANNEL` in app-page.ts. It runs in the window's own page, never in the app's iframes.
+const { contextBridge, ipcRenderer } = require('electron')
+
+contextBridge.exposeInMainWorld('acrylBlendsApp', {
+  call: (op, arg) => ipcRenderer.invoke('acrylblends:app', op, arg),
+})

package/plugins/desktop/product.ts

@@ -0,0 +1,117 @@
+/**
+ * A product build (M10 T002): a desktop package that ships an app as its own starting point. `product.json` at the bundle root marks it. The bundle is
+ * the Program, read-only (a mounted DMG can never be written to); the person's apps live in the product's root in the OS per-user data folder, one
+ * sealed folder each (plugins/instance/storage.ts, specs/049-framework-architecture/app-storage.md in ACRYL). A new app's source gets the person's
+ * part of the starting app only; the Program (product.json's `program`: the framework's plugins, the generated host, the packages) stays in the bundle
+ * and is served from there (plugins/instance/bundle.ts), so an update replaces it for every app.
+ */
+
+import { appendFileSync, cpSync, existsSync, mkdirSync, readFileSync } from 'node:fs'
+import { join, relative, sep } from 'node:path'
+import { inProgram, type Product } from '../instance/bundle.ts'
+import type { AppInstance } from '../instance/index.ts'
+import type { AppStorage } from '../instance/storage.ts'
+
+/**
+ * What a new app's source does not carry from the bundle besides the Program: build output, the bundle's own app data, and the carrier names the packager
+ * keeps files under. The scaffold's repository travels as `template-git` and becomes the source's `.git`; the other carriers become their files (see `CARRIED`).
+ */
+const SKIPPED = new Set([
+  'dist',
+  '.acrylblends',
+  'product.json',
+  'template-git',
+  'gitignore-product',
+  'gitattributes-product',
+  'package-product.json',
+])
+
+/**
+ * The app's own files that the packager drops or rewrites inside a bundle, and the plain names they travel under. electron-builder excludes `.gitignore` and `.gitattributes`
+ * by name, and it ships a filtered manifest (the `scripts` block goes), so neither can reach the source as itself; `seedSource` writes them back.
+ */
+const CARRIED: readonly { readonly carrier: string; readonly file: string }[] = [
+  { carrier: 'gitignore-product', file: '.gitignore' },
+  { carrier: 'gitattributes-product', file: '.gitattributes' },
+  { carrier: 'package-product.json', file: 'package.json' },
+]
+
+/** What the packager adds to the scaffold's repository: kept out of the source's `git status` through git's local exclude, never its tracked `.gitignore`. */
+const PRODUCT_NAMES = [
+  'product.json',
+  'gitignore-product',
+  'gitattributes-product',
+  'package-product.json',
+  'template-git/',
+] as const
+
+/** Keep the product's own names out of the source's `git status`, the way git's local exclude is meant for. */
+function ignoreProductFiles(source: string): void {
+  const git = join(source, '.git')
+  if (!existsSync(git)) return
+  const info = join(git, 'info')
+  const file = join(info, 'exclude')
+  const before = existsSync(file) ? readFileSync(file, 'utf8') : ''
+  const known = new Set(before.split('\n').map((line) => line.trim()))
+  const missing = PRODUCT_NAMES.filter((name) => !known.has(name))
+  if (missing.length === 0) return
+  mkdirSync(info, { recursive: true })
+  const separator = before === '' || before.endsWith('\n') ? '' : '\n'
+  appendFileSync(file, `${separator}${missing.join('\n')}\n`)
+}
+
+/**
+ * Fill a new app's empty source folder with the person's part of the bundle's starting app: its files, its repository and the files the packager could
+ * only carry under another name, without the Program. Run once, when the app is made (`AppStorage.create`); an app's source is the person's from then on
+ * and is never written here again.
+ * @param bundle - the bundled app (read-only).
+ * @param source - the new app's source folder.
+ * @param program - the Program's paths (product.json), which stay in the bundle.
+ */
+export function seedSource(bundle: string, source: string, program: readonly string[]): void {
+  cpSync(bundle, source, {
+    recursive: true,
+    dereference: true,
+    errorOnExist: false,
+    force: true,
+    // The bundled root arrives as a URL's directory and can end in a separator: paths are taken relative to it, never by index.
+    filter: (path) => {
+      const parts = relative(bundle, path).split(sep)
+      if (parts[0] === '') return true
+      if (SKIPPED.has(parts[0] ?? '')) return false
+      // A folder is compared with its trailing separator, so `plugins/acryl-router` is the Program's `plugins/acryl-router/`.
+      const tree = parts.join('/')
+      return !inProgram(program, tree) && !inProgram(program, `${tree}/`)
+    },
+  })
+  const templateGit = join(bundle, 'template-git')
+  if (existsSync(templateGit))
+    cpSync(templateGit, join(source, '.git'), { recursive: true, force: true })
+  for (const { carrier, file } of CARRIED) {
+    const from = join(bundle, carrier)
+    if (existsSync(from)) cpSync(from, join(source, file), { force: true })
+  }
+  ignoreProductFiles(source)
+}
+
+/**
+ * The app a product opens: the one opened last, or on the first start a new one seeded from the bundle and named after the product's starting app.
+ * Choosing among several apps and naming the first one are the frame's pages (app-storage.md slice 4).
+ */
+export function openProductApp(
+  storage: AppStorage,
+  product: Product,
+  bundle: string,
+  log: (line: string) => void = console.log,
+): AppInstance {
+  let app = storage.last()
+  if (app === undefined) {
+    log(`product: making the app "${product.appName}" from the bundled app (first start, one time)`)
+    // A product that is one Blend carries it in a folder of its bundle; the Blank product's starting app is the bundle's own tree.
+    const from = product.seed === undefined ? bundle : join(bundle, product.seed)
+    app = storage.create(product.appName, (source) => {
+      seedSource(from, source, product.program)
+    })
+  }
+  return storage.open(app.id)
+}

package/plugins/desktop/window.ts

@@ -7,6 +7,8 @@ export interface WindowSpec {
   /** Where the window's top left corner goes; Electron centers the window when these are left out. */
   readonly x?: number
   readonly y?: number
+  /** A product's preload (`preload.cjs`): the narrow bridge its App pages use. Sandboxed, isolated, main frame only. */
+  readonly preload?: string
 }
 
 export interface Rect {
@@ -84,6 +86,7 @@ export interface WindowOptions {
     readonly nodeIntegration: boolean
     readonly sandbox: boolean
     readonly webSecurity: boolean
+    readonly preload?: string
   }
 }
 
@@ -101,6 +104,7 @@ export function windowOptions(spec: WindowSpec): WindowOptions {
       nodeIntegration: false,
       sandbox: true,
       webSecurity: true,
+      ...(spec.preload === undefined ? {} : { preload: spec.preload }),
     },
   }
 }

package/plugins/desktop-web/main.ts

@@ -13,6 +13,7 @@ import { fileURLToPath } from 'node:url'
 import { serve } from 'acrylblends/node-server'
 import { app, BrowserWindow, shell } from 'electron'
 import 'acrylblends/node-server/register'
+import { appHomes } from '../instance/index.ts'
 import { createDesktopShutdown, installShutdownRequests } from './shutdown.ts'
 import { resolveDesktopUserDataOverride } from './user-data.ts'
 import { windowOptions } from './window.ts'
@@ -23,9 +24,9 @@ const manifest = JSON.parse(readFileSync(join(projectRoot, 'package.json'), 'utf
   acrylblends?: { desktopPath?: string }
 }
 
-/** Electron's user-data folder: an explicit DSH_DESKTOP_USER_DATA, else a folder inside the app's own folder. */
+/** Electron's user-data folder: an explicit DSH_DESKTOP_USER_DATA, else the app's cache folder under ~/.acryl (what Chromium keeps can be rebuilt). */
 const userData =
-  resolveDesktopUserDataOverride(process.env) ?? join(projectRoot, '.acrylblends', 'electron')
+  resolveDesktopUserDataOverride(process.env) ?? join(appHomes(projectRoot).cache, 'electron')
 mkdirSync(userData, { recursive: true, mode: 0o700 })
 app.setPath('userData', userData)
 app.setName(manifest.name ?? 'acryl-app')

package/plugins/desktop-web/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "desktop-web",
   "description": "Run a plain Acryl app (`export default app`) as a desktop app: an Electron window on the app's own server. `npm run desktop`; the app's code never imports electron. `acrylblends add desktop` picks this one for an app without the Blend plugins.",
-  "requires": [],
+  "requires": ["instance"],
   "inject": [],
   "provides": [],
   "dependencies": {},