@dopame/acde-linux-x64 0.0.0-stage → 0.0.10

package/lib/acde/skills/acde/references/start/install.md

@@ -0,0 +1,232 @@
+# Install
+
+The installer sets up acde (the CLI, the project templates, and the SDK) together with the runtime it pairs with, acdert, which runs your apps. No npm, no root. See [The runtime](#the-runtime).
+
+## With a coding agent
+
+Give your agent this prompt:
+
+```text
+Read https://pkgs.dopame.ai/acde/install.md and follow it to set up acde on this machine.
+```
+
+The page it reads tells it to check for Bun or Node.js, run the installer below, install the acde skill for itself, and report what is ready. See [Coding agents](../guide/agents.md).
+
+## Requirements
+
+acde runs on a JavaScript runtime you already have. Either one works:
+
+- [Bun](https://bun.sh) 1.4 or later
+- [Node.js](https://nodejs.org) 22.3 or later
+
+If you have both, acde uses Bun. The install script doesn't install either of them for you.
+
+`acde test` (end-to-end tests) runs on Bun only. With only Node.js, every other command works.
+
+## Supported platforms
+
+| System | CPU |
+| --- | --- |
+| macOS | Apple silicon (arm64), Intel (x86_64) |
+| Linux | x86_64 |
+| Windows | x64 |
+
+acde itself is JavaScript; these are the platforms the runtime is built for (`aarch64-apple-darwin`, `x86_64-apple-darwin`, `x86_64-unknown-linux-gnu`, `x86_64-pc-windows-msvc`), and the installer stops with this list on any other. The Windows installer is x64 only. What the runtime can do differs somewhat between them; see [Platform support](../reference/platforms.md).
+
+## macOS / Linux
+
+```sh
+curl -fsSL https://pkgs.dopame.ai/acde/install.sh | sh
+```
+
+This installs into `~/.acde` (change it with `ACDE_INSTALL`) and adds `~/.acde/bin` to PATH in the startup files of every shell on the machine, once each, and lists them: `~/.profile` (sh, dash, ksh and login shells), `~/.bashrc` and an existing `~/.bash_profile` or `~/.bash_login` (bash), `~/.zshrc` and `~/.zprofile` (zsh), `~/.config/fish/conf.d/acde.fish` (fish), `~/.cshrc` and an existing `~/.tcshrc` (csh, tcsh), and nushell's `env.nu`. In the sh-family files the line adds `~/.acde/bin` only when PATH doesn't have it yet, so a shell that reads several of them (a login zsh reads `.zprofile` and `.zshrc`) has it once; an unguarded line from an earlier install is replaced in place. Before each download it prints the file's name and size; in a terminal it shows a progress bar; after each one, and also when its output is captured (a coding agent, CI), it prints the file's size and that its SHA-256 matches. A download that stalls (under 1 KB/s for 30 seconds) is retried twice, then the installer stops and installs nothing.
+
+To leave your startup files alone:
+
+```sh
+curl -fsSL https://pkgs.dopame.ai/acde/install.sh | sh -s -- --no-modify-path
+```
+
+To install a specific version: `sh -s -- --version 0.0.9`. The oldest version on the download site is 0.0.9.
+
+## Windows
+
+In PowerShell:
+
+```powershell
+irm https://pkgs.dopame.ai/acde/install.ps1 | iex
+```
+
+This installs into `%USERPROFILE%\.acde` and adds it to your user `Path`. Like the macOS / Linux installer, it shows each download's progress (size, speed, time left) in a terminal, prints the size and SHA-256 check of each file, and gives up on a download that receives nothing for 30 seconds after three tries. If you turned progress off (`$ProgressPreference = 'SilentlyContinue'`), it stays off.
+
+After 0.0.9, in the classic Windows console (powershell.exe or cmd.exe started on their own), the boxes and frames that `acde new` and other prompts draw use ASCII characters (`+`, `-`, `|`); Windows Terminal and the VS Code terminal show line-drawing ones. Both work the same; Windows Terminal is recommended.
+
+`irm | iex` cannot pass parameters. Set environment variables before it, or run the script as a script block to pass its parameters `-Version` and `-NoModifyPath`:
+
+```powershell
+$env:ACDE_VERSION = '0.0.9'; $env:ACDE_NO_MODIFY_PATH = '1'
+irm https://pkgs.dopame.ai/acde/install.ps1 | iex
+
+& ([scriptblock]::Create((irm https://pkgs.dopame.ai/acde/install.ps1))) -Version 0.0.9 -NoModifyPath
+```
+
+## Installer options
+
+Both installers take the same options, each in its own form:
+
+| Option | `install.sh` | `install.ps1` |
+| --- | --- | --- |
+| Install a specific version (and its runtime) | `--version X.Y.Z` | `-Version X.Y.Z` or `ACDE_VERSION` |
+| Leave startup files / the user `Path` alone | `--no-modify-path` | `-NoModifyPath` or `ACDE_NO_MODIFY_PATH` set to any value |
+| Install somewhere else than `~/.acde` | `ACDE_INSTALL` | `ACDE_INSTALL` |
+
+In PowerShell, environment variables set this way stay set in that terminal; remove them afterwards (`Remove-Item Env:ACDE_VERSION`) if a later install should take the defaults.
+
+## Verify
+
+> **Open a new terminal first.** The installer changes `PATH` only for terminals opened after it, so in the terminal you installed from, `acde` is `command not found`. To use that terminal anyway, run the last line the installer printed (`export PATH=…`, or `$env:Path = …` in PowerShell).
+
+In the new terminal, run:
+
+```sh
+acde doctor
+```
+
+It checks what `acde dev` and `acde test` need: acde on PATH, Bun and Node.js, the runtime (found, runs, pairs with this acde, and its own check of its files and the GPU, on which it draws a test frame), and more. Each line begins `ok`, `warn`, `error` or `skip`, a line beginning `fix:` follows each problem, and the last line says whether everything is there. See [Check the setup](../guide/doctor.md).
+
+`acde --version` prints just the versions: acde, the SDK and contract level it was built with, and the runtime it found with its version and contract level.
+
+## The runtime
+
+`acde dev` and `acde test` run your app in the runtime, acdert. The installer puts the acdert release that this acde pairs with next to it: the binary as `bin/acdert` (`acdert.exe` on Windows) and its host files as `bin/app/`, both checked against the release's `SHA256SUMS`. The pairing is recorded with each acde release, so installing a specific version of acde (the installer's `--version X.Y.Z`, or `-Version X.Y.Z` on Windows) installs the runtime that version pairs with. If the runtime cannot be installed (no build for your platform, a failed download or checksum), the installer installs nothing and keeps what you had. Inside the Dopame virtual machine, `acdert` is already on PATH.
+
+acde looks for the runtime in this order:
+
+1. `ACDERT`: the path of an acdert binary, or the name of one on PATH;
+2. the acdert the installer put next to acde;
+3. `acdert` on PATH.
+
+There is no other place: acde does not look for a runtime built in a source checkout next to it, even when acde itself runs from source; set `ACDERT` to use one.
+
+When none is there, `acde dev` stops and says so, and `acde doctor` says where it looked and what to do.
+
+The runtime renders pages only on the GPU, so it needs a working GPU (Metal on macOS, DirectX 12 on Windows, Vulkan on Linux). On Linux that means the hardware Vulkan driver of the machine's GPU (Mesa: `vulkan-intel` or `vulkan-radeon` on Arch, `mesa-vulkan-drivers` on Debian, Ubuntu and Fedora; NVIDIA: the vendor's driver); a software renderer is not accepted. Without it `acde dev` fails at startup with a log line that begins `web layer unavailable:` and says `no usable Vulkan driver was found: install the GPU's Vulkan driver …`: install the driver and check that `vulkaninfo --summary` lists the GPU. `acde doctor` shows the same line as an error of its `gpu` check before you start anything.
+
+### Install the runtime by hand
+
+Use this only when the installer cannot set up the runtime, for example without access to `https://pkgs.dopame.ai/` from the machine. The result is an `acdebin-dbg` binary with its `app/` directory next to it; set `ACDERT` to the path of that binary (`~/.acdebin-dbg/acdebin-dbg` in the commands below). The runtime is released together with acde, in `https://pkgs.dopame.ai/acde/<version>/`, and `https://pkgs.dopame.ai/acde/latest` names the latest version. A release has:
+
+| File | What it is |
+| --- | --- |
+| `acdebin-dbg-aarch64-apple-darwin.tar.xz` | The runtime for macOS on Apple silicon |
+| `acdebin-dbg-x86_64-apple-darwin.tar.xz` | The runtime for macOS on Intel |
+| `acdebin-dbg-x86_64-unknown-linux-gnu.tar.xz` | The runtime for Linux x86_64 |
+| `acdebin-dbg-x86_64-pc-windows-msvc.tar.gz` | The runtime for Windows x64 |
+| `acde-host-<version>.tar.gz` | The runtime's own scripts (an `app/` directory) and its license, the same on every platform |
+| `acde-<version>.tar.gz` | acde itself (what the installer puts in `~/.acde`) |
+| `acde-api-<version>.tar.gz` | The SDK, `@dopame/acde-api`, that projects install as a dev dependency (see [Project layout](project.md#sdk)); not needed to run the runtime |
+| `SHA256SUMS` | Checksums of the files above |
+
+Each runtime archive holds only the binary, `acdebin-dbg` (`acdebin-dbg.exe` on Windows).
+
+Download the archive for your platform, the host archive, and `SHA256SUMS`, and check them. Extract both into the same directory: the runtime looks for `app/` next to itself and does not start without it. On Linux, extracting a `.tar.xz` needs `xz` (the `xz` or `xz-utils` package).
+
+On macOS or Linux, paste the lines below, with `target` set for your platform (the parentheses keep your terminal in its current directory): `aarch64-apple-darwin` on Apple silicon, `x86_64-apple-darwin` on an Intel Mac, `x86_64-unknown-linux-gnu` on Linux.
+
+```sh
+(
+target=aarch64-apple-darwin
+base=https://pkgs.dopame.ai/acde
+version=$(curl -fsSL "$base/latest" | tr -d ' \r\n')
+mkdir -p ~/.acdebin-dbg && cd ~/.acdebin-dbg
+curl -fsSLO "$base/$version/acdebin-dbg-$target.tar.xz" -O "$base/$version/acde-host-$version.tar.gz" -O "$base/$version/SHA256SUMS"
+grep -E " (acdebin-dbg-$target\.tar\.xz|acde-host-$version\.tar\.gz)\$" SHA256SUMS | sha256sum -c - &&
+  rm -rf app && tar -xzf "acde-host-$version.tar.gz" && tar -xJf "acdebin-dbg-$target.tar.xz"
+)
+```
+
+`sha256sum` prints `OK` for both files; if it doesn't, nothing is extracted. Then point acde at it: add this line to your shell's startup file, and run it in the current terminal too:
+
+```sh
+export ACDERT="$HOME/.acdebin-dbg/acdebin-dbg"
+```
+
+Adding `~/.acdebin-dbg` to `PATH` works as well.
+
+On Windows, in PowerShell:
+
+```powershell
+& {
+  $ProgressPreference = 'SilentlyContinue'
+  $base = 'https://pkgs.dopame.ai/acde'
+  $version = (Invoke-RestMethod "$base/latest").Trim()
+  $dir = "$env:USERPROFILE\.acdebin-dbg"
+  New-Item -ItemType Directory -Force $dir | Out-Null
+  $files = 'acdebin-dbg-x86_64-pc-windows-msvc.tar.gz', "acde-host-$version.tar.gz"
+  foreach ($f in $files + 'SHA256SUMS') { Invoke-WebRequest "$base/$version/$f" -OutFile "$dir\$f" }
+  $sums = Get-Content "$dir\SHA256SUMS"
+  foreach ($f in $files) {
+    $want = (($sums | Where-Object { $_ -like "* $f" }) -split ' ')[0]
+    if ((Get-FileHash "$dir\$f").Hash -ne $want) { throw "checksum mismatch: $f" }
+  }
+  Remove-Item -Recurse -Force "$dir\app" -ErrorAction SilentlyContinue
+  tar -xzf "$dir\acde-host-$version.tar.gz" -C $dir
+  tar -xzf "$dir\acdebin-dbg-x86_64-pc-windows-msvc.tar.gz" -C $dir
+  [Environment]::SetEnvironmentVariable('ACDERT', "$dir\acdebin-dbg.exe", 'User')
+  $env:ACDERT = "$dir\acdebin-dbg.exe"
+}
+```
+
+This sets `ACDERT` for your user and for the current terminal.
+
+To upgrade the runtime, run the same commands again. Check that it works with a new project:
+
+```sh
+acde new hello --template html --yes
+cd hello
+acde dev
+```
+
+### Install the Dopame desktop
+
+On its own, `acde dev` runs only your app. To run it inside Dopame's desktop (`acde dev --desktop dopame`, `acde test --desktop dopame`), install the `dopame` desktop package too. It is published apart from acde and the runtime, on `pkgs.dopame.ai`: `https://pkgs.dopame.ai/acde-dopame/latest.json` gives the latest build: its `base` is the directory with `dopame.tar.gz` and `SHA256SUMS`. The archive holds one package directory, `dopame/`; extract it into the package directory `$XDG_DATA_HOME/acde/packages` (by default `~/.local/share/acde/packages`):
+
+```sh
+(
+base=$(curl -fsSL https://pkgs.dopame.ai/acde-dopame/latest.json | sed -n 's/.*"base": *"\([^"]*\)".*/\1/p')
+packages="${XDG_DATA_HOME:-$HOME/.local/share}/acde/packages"
+mkdir -p "$packages" && cd "$(mktemp -d)"
+curl -fsSLO "${base}dopame.tar.gz" -O "${base}SHA256SUMS"
+sha256sum -c SHA256SUMS &&
+  rm -rf "$packages/dopame" && tar -xzf dopame.tar.gz -C "$packages"
+)
+```
+
+On Windows the package directory is `%USERPROFILE%\.local\share\acde\packages`; extract the same archive there with `tar -xzf dopame.tar.gz -C <that directory>`.
+
+Then, in your project:
+
+```sh
+acde dev --desktop dopame
+```
+
+Your app is in the desktop's app list; open it from there. The desktop's assistant needs a program that is not part of this download, so the output has a warning about it (`no assistant`); everything else works. For where the runtime looks for packages, see [Local install](../guide/install.md#package-lookup).
+
+## Upgrade and uninstall
+
+To upgrade, run the install command again; it upgrades the runtime too. Each version is installed in `~/.acde/versions/<version>`, with its runtime in its `bin`, and `~/.acde/current` points to the one in use. After 0.0.9, the installer keeps the version it installs and the one it replaces, and removes older ones (about 100 MB each); a version a running program still uses (an `acde dev` started from it) stays until the next install.
+
+`acde uninstall` removes installed apps and desktops, not acde itself (see [Local install](../guide/install.md#uninstall)). To uninstall acde, run `acde skills remove` if you installed the skill, delete `~/.acde`, and remove the `# acde` lines the installer added to your shells' startup files (it listed them); on Windows remove `%USERPROFILE%\.acde\current\bin` from your user `Path` and the user variable `ACDE_INSTALL`. If you installed the runtime by hand or the desktop as above, also delete `~/.acdert` and remove the `ACDERT` line.
+
+acde and the runtime keep data outside the install directory. Delete these too to remove everything; otherwise a later install finds the old apps, desktops and their data again. The same paths are used on macOS; on Windows, without `XDG_*` variables, they are under `%USERPROFILE%` with the same names (`%USERPROFILE%\.local\share\acde` and so on):
+
+| Directory | What is in it |
+| --- | --- |
+| `$XDG_DATA_HOME/acde` (`~/.local/share/acde`) | Installed apps and desktops (`packages/`), the apps' backend data (`apps/<id>/`), storage (`storage/app-<id>/`, `storage/desktop-<id>/`) and private files (`files/<id>/`), the skill install record (`skills.json`) |
+| `$XDG_STATE_HOME/acde` (`~/.local/state/acde`) | Window positions, folder grants (`grants/<id>.json`), the last desktop, and other session state |
+| `$XDG_CONFIG_HOME/acde` (`~/.config/acde`) | Approval decisions (`permissions.json`) |
+| `$XDG_CONFIG_HOME/acde-mimeapps.list` and `$XDG_CONFIG_HOME/acde-extensions.list` (`~/.config/…`) | The default app chosen for a file type or extension |
+| `$XDG_CACHE_HOME/acde` (`~/.cache/acde`) | Caches (only when `XDG_RUNTIME_DIR` is not set) |
+| `acde/devtools` under `~/Library/Caches` (macOS), `%LOCALAPPDATA%` (Windows) or `$XDG_CACHE_HOME` (`~/.cache`, Linux) | The browser profile that `acde devtools` and F12 open DevTools in (after 0.0.9) |
+
+On Windows, reinstalling the same version while `acde dev` runs moves the files in use aside (`versions/<version>.old-…`); the installer says so, and removes them the next time it runs.

package/lib/acde/skills/acde/references/start/project.md

@@ -0,0 +1,77 @@
+# Project layout
+
+A project created with `acde new my-app --backend`:
+
+```text
+my-app/
+├── acde.config.jsonc    app config: id, name, icon, entry, capabilities
+├── package.json
+├── index.html           entry page
+├── src/main.js
+├── src/i18n.js         picks the language and fills in interface text
+├── src/locales/         one message table per language: en.js, zh.js
+├── server.ts            backend (optional)
+├── public/              static files copied as is (optional)
+└── .acde/               build output, kept out of git
+```
+
+## Interface languages
+
+The `html` and `desktop` templates keep interface text out of the markup, in one table per language under `src/locales/` (`en.js`, `zh.js`, each `export default { key: 'text' }`). `src/i18n.js` uses only the platform, no library:
+
+- `locale` is chosen from `navigator.language`: the exact tag if there is a table for it (`zh-TW.js`), else its base language (`zh`, via `Intl.Locale`), else `en`. A key a table lacks falls back to its English text.
+- `t(key, values)` returns the text with `{name}` placeholders filled in.
+- `translate()` sets `<html lang>` to `locale` and fills every element with a `data-i18n="key"` attribute; `index.html` ships with `lang="en"` until then.
+
+To add a language, add `src/locales/<tag>.js` with the same keys as `en.js` and import it in `i18n.js`. Format dates and numbers with `Intl` and `locale` (`new Intl.DateTimeFormat(locale)`). Framework templates keep the UI their own scaffolder writes.
+
+## Config and manifest
+
+- **`acde.config.jsonc`** is the config you write. It's only read at build time. `"type"` is `"app"` (a windowed app) or `"desktop"` (a desktop).
+- The **manifest** is the `acde` field of `package.json` in the build output, `.acde/`. That directory is a **package**: what the runtime runs. The manifest is the only thing the runtime reads.
+
+`acde build` turns the former into the latter. Most of the time you only need to care about the config; for the manifest format, see [Manifest](../reference/manifest.md).
+
+A directory without `acde.config.jsonc` can still be built:
+
+- If the `acde` field in `package.json` has `apps`, it's treated as a **handwritten package** and used as is (only checked).
+- Otherwise it's treated as a default app: the entry is `index.html`, the id is derived from `name` in `package.json`, and the display name comes from `displayName` or `productName`.
+
+## Build output
+
+After building the app `my-app`:
+
+```text
+.acde/
+├── package.json         manifest
+├── web/                 web pages, served at /app/my-app/ in the runtime
+└── backend/
+    ├── server.js        bundled backend
+    ├── package.json     {"type": "module"}
+    └── acde-listen.js   preload that turns the backend's listen into a unix socket
+```
+
+A desktop project produces `desktop/` (served at `/desktop/<id>/`), `services/<name>.js`, and `apps/<id>/{web,backend}` for the apps it bundles.
+
+## JavaScript runtime and package manager
+
+Whether a project runs on Bun or Node.js is decided by its package manager: `bun` → Bun; `npm` / `pnpm` / `yarn` → Node.js. For an existing project, acde looks at the lockfile, then at the `packageManager` field in `package.json`; with neither, the project runs on the runtime acde itself runs on. `acde new` writes `packageManager` for you.
+
+On Node.js, acde bundles with the project's own Vite (which is why the built-in templates add `vite` as a dev dependency under npm / pnpm / yarn); on Bun it uses `Bun.build`. The bundling rules are the same on both.
+
+## SDK
+
+The project's dev dependencies include `@dopame/acde-api`, the SDK version this acde was built with, as a tarball from `https://pkgs.dopame.ai/acdert/<version>/` (so the project installs on any machine and in CI; the SDK is not on npm). `acde new` installs it. After upgrading acde, `acde check` and `acde dev` say when the project's SDK is older; `acde sdk update` brings it to the version this acde pairs with. It provides:
+
+- The JSON Schema for `acde.config.jsonc` (editor completion)
+- TypeScript types for all `acde:` modules and the manifest
+- `load()`: load an `acde:` module optionally
+- The Vite plugin `@dopame/acde-api/vite`
+
+To reference the types in a JS file:
+
+```js
+/// <reference types="@dopame/acde-api/app" />
+```
+
+In a TypeScript project, add `"@dopame/acde-api/app"` to `compilerOptions.types` in `tsconfig.json`. A desktop's pages use `@dopame/acde-api/shell` instead, which adds the modules only a desktop gets; `@dopame/acde-api` declares all of them.

package/lib/acde/templates/app/acde.config.jsonc

@@ -0,0 +1,27 @@
+{
+  "$schema": "./node_modules/@dopame/acde-api/config.schema.json",
+  // A window app: a plain web page (index.html), with an optional backend in server.ts. System features come from
+  // acde:* modules (import { fs } from 'acde:fs'), granted by capabilities. For editor types write
+  // /// <reference types="@dopame/acde-api/app" /> (the app modules; shell modules are only for desktops and their own apps).
+  "type": "app",
+  "id": "{{id}}",
+  "label": "{{label}}",
+  // icon: an icon name (app, timer, chart … see @dopame/acde-api) or an .svg / .png in the project (like "icon.svg"),
+  // copied into the package at build time.
+  "icon": "app",
+  "entry": "index.html",
+  // capabilities: the system features the app uses. "fs": true gives the app's private folder and the folders the user
+  // picks for it; name public places in fs.roots, and declaring one is what gives the app access to it:
+  // "fs": { "roots": ["documents"] }
+  // (desktop, documents, downloads, music, pictures, videos).
+  "capabilities": {},
+  // optional: capabilities the app can run without; they are not imported statically but taken with
+  // load('<name>') from @dopame/acde-api.
+  "optional": [],
+  // services: desktop services the app uses (import 'acde:<name>'); not the name of a system module.
+  "services": [],
+  // requests: the private requests the app accepts (another app calls open('{{id}}', { kind: '<name>' }));
+  // schemes: the URL schemes whose links it opens (lower case, without the colon).
+  "requests": [],
+  "schemes": []
+}

package/lib/acde/templates/app/gitignore

@@ -0,0 +1,2 @@
+node_modules/
+.acde/

package/lib/acde/templates/app/index.html

@@ -0,0 +1,22 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="color-scheme" content="light dark" />
+    <title>{{label}}</title>
+    <style>
+      :root { color-scheme: light dark }
+      body { margin: 0; padding: 32px; font: 15px/1.5 system-ui, sans-serif; color: #1f1d26; background: #f6f5fa }
+      h1 { margin: 0 0 8px; font-size: 22px }
+      @media (prefers-color-scheme: dark) {
+        body { color: #e8e6f0; background: #1f1d26 }
+      }
+    </style>
+  </head>
+  <body>
+    <h1>{{label}}</h1>
+    <p data-i18n="intro"></p>
+    <p id="status"></p>
+    <script type="module" src="./src/main.js"></script>
+  </body>
+</html>

package/lib/acde/templates/app/package.json

@@ -0,0 +1,5 @@
+{
+  "name": "{{id}}",
+  "private": true,
+  "type": "module"
+}

package/lib/acde/templates/app/src/i18n.js

@@ -0,0 +1,26 @@
+import en from './locales/en.js'
+import zh from './locales/zh.js'
+
+const catalogs = { en, zh }
+
+function pick(tag) {
+  if (tag in catalogs) return tag
+  try {
+    const { language } = new Intl.Locale(tag)
+    if (language in catalogs) return language
+  } catch {}
+  return 'en'
+}
+
+export const locale = pick(navigator.language)
+const messages = { ...en, ...catalogs[locale] }
+
+export function t(key, values = {}) {
+  const text = messages[key] ?? key
+  return text.replace(/\{(\w+)\}/g, (all, name) => (name in values ? String(values[name]) : all))
+}
+
+export function translate(root = document) {
+  document.documentElement.lang = locale
+  for (const element of root.querySelectorAll('[data-i18n]')) element.textContent = t(element.dataset.i18n)
+}

package/lib/acde/templates/app/src/locales/en.js

@@ -0,0 +1,4 @@
+export default {
+  intro: 'Edit index.html and src/main.js; acde dev reloads the page.',
+  status: 'Language {language} · {time}',
+}

package/lib/acde/templates/app/src/locales/zh.js

@@ -0,0 +1,4 @@
+export default {
+  intro: '编辑 index.html 和 src/main.js，acde dev 会自动刷新页面。',
+  status: '语言 {language} · {time}',
+}

package/lib/acde/templates/app/src/main.js

@@ -0,0 +1,5 @@
+import { locale, t, translate } from './i18n.js'
+
+translate()
+const time = new Intl.DateTimeFormat(locale, { dateStyle: 'medium', timeStyle: 'short' }).format(new Date())
+document.querySelector('#status').textContent = t('status', { language: navigator.language, time })

package/lib/acde/templates/backend/server.ts

@@ -0,0 +1,7 @@
+export default {
+  fetch(request: Request): Response {
+    const url = new URL(request.url)
+    if (url.pathname === '/api/hello') return Response.json({ hello: '{{label}}', at: new Date().toISOString() })
+    return new Response('not found', { status: 404 })
+  },
+}

package/lib/acde/templates/backend/src/main.js

@@ -0,0 +1,6 @@
+import { locale, t, translate } from './i18n.js'
+
+translate()
+const answer = await (await fetch('/api/hello')).json()
+const time = new Intl.DateTimeFormat(locale, { dateStyle: 'medium', timeStyle: 'medium' }).format(new Date(answer.at))
+document.querySelector('#status').textContent = t('status', { language: navigator.language, time })

package/lib/acde/templates/desktop/acde.config.jsonc

@@ -0,0 +1,17 @@
+{
+  "$schema": "./node_modules/@dopame/acde-api/config.schema.json",
+  // A desktop: one full-screen web page behind all windows. System features come from acde:* modules, both the app and
+  // the shell modules. For editor types write /// <reference types="@dopame/acde-api/shell" />.
+  "type": "desktop",
+  "id": "{{id}}",
+  "label": "{{label}}",
+  "entry": "index.html",
+  // services: desktop services that run in acde: name → module file, like "clock": "services/clock.ts". A service
+  // name is not the name of a system module. A service works with its context (ctx.log, ctx.spawn, ctx.state,
+  // ctx.inspect) and cannot import acde:* modules; ctx.import('acde:<name>') gives it the shell modules its entry
+  // lists: "clock": { "module": "services/clock.ts", "modules": ["windows"] }.
+  "services": {},
+  // apps: the window apps this desktop brings along (system apps). Each declares capabilities, optional, services,
+  // requests and schemes like a "type": "app" project, and may also declare shell modules (like "windows": true).
+  "apps": []
+}

package/lib/acde/templates/desktop/gitignore

@@ -0,0 +1,2 @@
+node_modules/
+.acde/

package/lib/acde/templates/desktop/index.html

@@ -0,0 +1,19 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="color-scheme" content="dark" />
+    <title>{{label}}</title>
+    <style>
+      html, body { height: 100%; margin: 0 }
+      body { display: flex; flex-direction: column; justify-content: flex-end; font: 14px/1.4 system-ui, sans-serif; color: #f4f2fa; background: linear-gradient(160deg, #2b2440, #12101a) }
+      nav { display: flex; gap: 8px; margin: 0 auto 16px; padding: 8px; border-radius: 16px; background: #ffffff1f }
+      button { padding: 8px 14px; border: 0; border-radius: 10px; color: inherit; background: #ffffff14; font: inherit; cursor: pointer }
+      button:hover { background: #ffffff33 }
+    </style>
+  </head>
+  <body>
+    <nav id="dock"></nav>
+    <script type="module" src="./src/desktop.js"></script>
+  </body>
+</html>

package/lib/acde/templates/desktop/package.json

@@ -0,0 +1,5 @@
+{
+  "name": "{{id}}",
+  "private": true,
+  "type": "module"
+}

package/lib/acde/templates/desktop/src/desktop.js

@@ -0,0 +1,16 @@
+/// <reference types="@dopame/acde-api/shell" />
+import { apps } from 'acde:apps'
+import { t, translate } from './i18n.js'
+
+translate()
+const dock = /** @type {HTMLElement} */ (document.querySelector('#dock'))
+dock.setAttribute('aria-label', t('dock'))
+const list = await apps.list()
+if (list.length === 0) dock.textContent = t('empty')
+for (const app of list) {
+  const button = document.createElement('button')
+  button.type = 'button'
+  button.textContent = app.label
+  button.addEventListener('click', () => void apps.open(app.id))
+  dock.append(button)
+}

package/lib/acde/templates/desktop/src/i18n.js

@@ -0,0 +1,26 @@
+import en from './locales/en.js'
+import zh from './locales/zh.js'
+
+const catalogs = { en, zh }
+
+function pick(tag) {
+  if (tag in catalogs) return tag
+  try {
+    const { language } = new Intl.Locale(tag)
+    if (language in catalogs) return language
+  } catch {}
+  return 'en'
+}
+
+export const locale = pick(navigator.language)
+const messages = { ...en, ...catalogs[locale] }
+
+export function t(key, values = {}) {
+  const text = messages[key] ?? key
+  return text.replace(/\{(\w+)\}/g, (all, name) => (name in values ? String(values[name]) : all))
+}
+
+export function translate(root = document) {
+  document.documentElement.lang = locale
+  for (const element of root.querySelectorAll('[data-i18n]')) element.textContent = t(element.dataset.i18n)
+}

package/lib/acde/templates/desktop/src/locales/en.js

@@ -0,0 +1,4 @@
+export default {
+  dock: 'Apps',
+  empty: 'No apps installed yet',
+}

package/lib/acde/templates/desktop/src/locales/zh.js

@@ -0,0 +1,4 @@
+export default {
+  dock: '应用',
+  empty: '还没有安装应用',
+}

package/lib/acde/templates/framework/acde.config.jsonc

@@ -0,0 +1,26 @@
+{
+  "$schema": "./node_modules/@dopame/acde-api/config.schema.json",
+  // A window app: a {{framework}} project; acde build uses its own build. System features come from
+  // acde:* modules (import { fs } from 'acde:fs'), granted by capabilities. For editor types write
+  // /// <reference types="@dopame/acde-api/app" /> (the app modules; shell modules are only for desktops and their own apps).
+  "type": "app",
+  "id": "{{id}}",
+  "label": "{{label}}",
+  // icon: an icon name (app, timer, chart … see @dopame/acde-api) or an .svg / .png in the project (like "icon.svg"),
+  // copied into the package at build time.
+  "icon": "app",
+  // capabilities: the system features the app uses. "fs": true gives the app's private folder and the folders the user
+  // picks for it; name public places in fs.roots, and declaring one is what gives the app access to it:
+  // "fs": { "roots": ["documents"] }
+  // (desktop, documents, downloads, music, pictures, videos).
+  "capabilities": {},
+  // optional: capabilities the app can run without; they are not imported statically but taken with
+  // load('<name>') from @dopame/acde-api.
+  "optional": [],
+  // services: desktop services the app uses (import 'acde:<name>'); not the name of a system module.
+  "services": [],
+  // requests: the private requests the app accepts (another app calls open('{{id}}', { kind: '<name>' }));
+  // schemes: the URL schemes whose links it opens (lower case, without the colon).
+  "requests": [],
+  "schemes": []
+}

package/lib/acde-api/LICENSE

@@ -0,0 +1,5 @@
+Copyright (c) 2026 Dopame. All rights reserved.
+
+This software is proprietary and confidential. No part of it may be
+copied, modified, distributed or used without prior written permission
+from Dopame.