Start with a task instead · Open the prompt desk

How App Composer works

App Composer prepares an environment and connects independently maintained apps. An authorised agent carries out the work; EmDash manages the catalogue.

First time? Follow the complete app tutorial · Detailed setup help

Read the original visual architecture explainers

From an idea to a live app

  1. Get Ready. The agent checks its actual workspace, GitHub and Cloudflare tools. It verifies the target and deploys the configurable Hello World reference over HTTPS.
  2. Init. Choose a useful preset and customise real fields. Export a versioned spec and a matching prompt, without credentials.
  3. Compose. Pin independent source commits, validate their declared routes, data versions and capabilities, and connect their real item/action interface.
  4. Verify. Check source identity and live interaction, not just HTTP 200 or a green build.

Get Ready works on its own.

The same reusable core powers Composer’s readiness command and an independent Node consumer. It checks the actual agent, GitHub access, Cloudflare account and HTTPS source, saves private progress and rechecks it on resume. A provider interruption stays with the agent for retry; confirmed authentication or permission problems identify the human step.

The independent consumer has redeployed the reviewed Hello reference and verified its exact source on the existing custom domain. Deployment is an explicit operation with fresh prerequisite, source, account and route checks. The deployment operation cannot run an arbitrary repository or create cloud infrastructure.

Use the engine in your own tool.

v0.9.0 · MIT · Node 22, 24 or 26

Download the same library and command used by Composer. Keep your own interface, workspace and credentials. The archive has no runtime package dependencies or install scripts.

123 KB · Release source 5b583a9885f2. Review the source and bundled README before running it. The manifest checks a matching download; it is not an independent signature.

Install the downloaded archive

Check the archive’s SHA-256 against the manifest, then install it in the local project you chose for this integration.

npm install --ignore-scripts --no-audit --no-fund ./get-ready-core.tgz
./node_modules/.bin/get-ready --help
./node_modules/.bin/get-ready --workspace /absolute/authorised/workspace --report

The last command checks that workspace and saves private progress there. An incomplete setup returns a report with the next action. Setup operations require a separate explicit request. This archive is served here; it has not been published to the npm registry.

SHA-256 41ec6206d972df63baa3a05879eacfb7816f32574e58f3f6bfb68020afa1a003

Check readiness in OpenCode

After installing the archive, ask your active OpenCode session to run this command from the install folder. It checks the workspace, GitHub access, Cloudflare through the workspace’s pinned Wrangler and the deployed Hello reference.

./node_modules/.bin/get-ready --inspect-agent opencode

Use --workspace /absolute/authorised/workspace to check a different folder. This check leaves saved readiness progress untouched. The bundled README lists the flags for choosing a specific Cloudflare account and Hello target.

Library, API and MCP

Import runLocalReadiness, referenceTarget and readinessReport from @loftwah/get-ready. The bundled README has a working integration example. Session and adapter exports use the same engine; report and address-preference modules have separate exports.

The optional local MCP adapter has its own archive with SDK dependencies. Those dependencies are excluded from this core archive. A hosted API is still unexposed.

Read the MIT core · Use the standalone example

An explicit clone operation can prepare the maintained Hello source in a new directory from an authorised Codex folder, including one without a Git repository. It checks active tools and a fresh GitHub source read before creating the destination. It preserves existing files and verifies the exact checkout. Your agent must then check that destination itself; cloning grants no upstream push permission. A separate explicit ownership operation can create a new personal private GitHub repository from the unchanged starter, verify its source and rebind the checkout. It refuses existing names and requires a new workspace check. The same installer can prepare local tools in an unchanged personal private copy after checking actual ownership, permission and source. It excludes owner registry files/hooks and preserves an existing partial installation. A separate prepare-reference-target operation checks the existing Cloudflare account, its workers.dev subdomain and an unused Worker name, then prepares only the owned starter’s local deployment configuration. The name is not reserved; no cloud resource is created. After reviewing, committing and pushing that change, the agent can explicitly deploy the owned starter to the unused address. It rechecks private ownership, write permission and current source, builds a temporary snapshot without ignored local files, then verifies routing and the exact HTTPS source. An occupied or partially created Worker is preserved for inspection; there is no automatic retry or overwrite. This supports the prepared configuration only, with all other source bytes matching the maintained starter. Owned Init supports the title/introduction/theme on that verified workers.dev starter. A separate explicit update requires its previous source and currently active single Worker version; both are rechecked before upload and the new live source/version is verified. General source updates and cleanup remain unfinished; the maintained-source release path stays separate. The supported Mac path can install missing pinned dependencies in that reviewed checkout, verify its local Wrangler and resume deployment. Local tool preparation does not require upstream push permission. Deployment keeps its GitHub write and target checks; successful preparation alone does not make the checkout ready. A repeat leaves working tools alone. Global tool installation, initial account/domain setup and fresh-user provisioning remain work to prove. The local programmatic boundary is available; a hosted API remains unexposed. The local MCP adapter’s default tools recheck the host-selected environment without setup operations; local tool preparation and maintained starter acquisition each need their separate host selection. Composer and the dashboard extension currently hand execution to your authorised agent.

Let another agent check the same environment.

The optional local Get Ready MCP adapter uses the existing engine. Its default tools recheck the environment and inspect the latest dated report. An explicitly selected domain enables the separate read-only domain diagnosis. The host selects the trusted workspace and target before connecting; tool calls cannot change them.

Checks keep credentials and private receipts in the local runtime. They return the redacted progress report used by this website. Default tools cannot install, sign in, create repositories, change DNS or deploy. Optional workspace tool preparation and maintained starter acquisition require separate host selections; their scopes and supported runtime are explained below. A check can save private progress; inspection makes no provider calls.

Connect a local MCP host.

v0.12.1 · MIT · Node 22, 24 or 26

Install the existing stdio server without copying a Composer checkout. It includes the same core source and adds two pinned transport dependencies: the official MCP SDK and Zod.

134 KB · Release source 5b583a9885f2. Review the source and bundled README before running it. The manifest checks a matching download; it is not an independent signature.

Install and select a local host

Check the SHA-256 and review the bundled source. In a local integration folder chosen for this purpose, use Node 22, 24 or 26 and install with lifecycle scripts disabled. This needs an approved npm registry for dependencies, or an already populated cache.

npm install --ignore-scripts --no-audit --no-fund ./get-ready-mcp.tgz
/absolute/integration/node_modules/.bin/get-ready-mcp --workspace /absolute/authorised/project

Keep the generated dependency lockfile. Add the absolute executable and workspace to your host’s supported stdio configuration; the second line is a server launch, not a report command. No host configuration or account is changed by installation. Credentials stay in the host’s approved runtime handling, outside launch arguments.

SHA-256 7c6e0335e3552befd497ca2e11965a6a85151979ab88dfe214515b7a7c5e4a60

Host scope and available tools

The host fixes the workspace and any known account/reference before connecting. get_ready_check rechecks through the shared doctor and saves private progress; get_ready_inspect reads this connection’s last result. Tool calls keep the host’s selected scope. Checks cannot install, sign in or deploy.

The host can separately enable read-only domain diagnosis and project guidance inspection. To fetch the maintained Hello starter, an authorised host can select --reference-destination /absolute/authorised/new-hello. This enables get_ready_clone_reference for that destination only. Existing or partial files stay intact; no dependencies, project code, ownership or deployment run. The connection keeps its original workspace. Select the acquired checkout and any prepared tools explicitly on a new connection. Follow the bundled README for exact flags, disconnection and recovery. Missing targets remain incomplete. A protocol connection does not verify a customer environment or a particular agent’s capabilities.

Optional tool preparation

A host authorised to prepare missing local tools can add --allow-workspace-tool-setup to its launch. This enables the separate get_ready_prepare_tools operation for the selected workspace. It stays off by default.

The supported path is active Codex on an Apple Silicon Mac with Node 22, 24 or 26 and Git. It verifies existing tools or prepares a pinned GitHub CLI/pnpm pair in the workspace’s private folder. Select the repository root or a folder outside Git; existing and partial copies stay intact. Global tools, profiles, sign-in, DNS and deployment are untouched.

The result reports what preparation completed alongside readiness. A working tool pair does not verify account access or an online app. Ordinary checks reuse a successfully prepared pair on this connection and never retry setup. After reconnecting, explicitly select the prepared folder with --tools-workspace /absolute/authorised/project, or request a separate preparation check. Inspect retained work before retrying a cancelled or failed operation.

Connection command and supported boundary

The real stdio consumer verified the existing operator environment through the same core. A native host installation and fresh-customer setup still need acceptance. This website provides no remote execution endpoint.

Know what your domain needs.

The same Get Ready package exposes diagnoseDomain({account,domain}) and inspectDomainReport(report). The agent selects the exact account and zone name. It compares Cloudflare’s assigned nameservers with a public resolver observation and checks the DNSSEC setting and published DS records. It never edits DNS or opens a workspace receipt.

get-ready --inspect-domain example.com --account SELECTED_ACCOUNT_ID

The command exports a portable domain report. A nonzero result can still contain a valid report that explains incomplete checks. Open it in Get Ready’s domain viewer, or try its clearly labelled fictional migration example. Reports are read locally and are not uploaded or saved.

For a local MCP host, add --domain example.com --account SELECTED_ACCOUNT_ID to its trusted launch configuration. This exposes the optional get_ready_domain tool with no model-selected account, domain or arguments. It uses the same implementation and cannot change nameservers, create a zone or deploy.

Existing authorised Zone Read and DNSSEC Read access is required; this does not obtain or widen permissions. Current scope is full Cloudflare DNS setup. Partial/secondary and multi-signer configurations need separate inspection. Cached recursive DNS is an observation, not authoritative registrar state, worldwide propagation or a cryptographic DNSSEC audit. Domain diagnosis never replaces the separate exact-source HTTPS deployment proof.

Cloudflare nameserver guidance · DNSSEC and migration order

Missing tools have a supported next step.

On the supported Apple Silicon Mac with active Codex, Node 22, 24 or 26 and Git, your agent can run node scripts/ready.mjs --workspace PATH --install-workspace-tools. Usable existing tools are reused. Missing GitHub CLI or pnpm gets a verified private pair inside that folder, including pnpm’s runtime and licences. No machine installation or shell profile is changed.

The agent selects --use-workspace-tools for later checks in that folder, or --tools-workspace PATH to reuse the pair from a new starter checkout. Each selection checks the complete installed files before execution. An incomplete or changed folder is preserved for inspection. A normal resume never installs, switches tools or retries an operation automatically.

Preparation grants no account or deployment access. Git and Node installation, other operating systems, first accounts and domain setup remain separate work. Commands and reviewed distribution sources.

Give each app its own settings.

In Init, open Settings for each app. The reviewed Guestbook and Linkarooie contracts provide the fields, choices and limits. Enable a separate group to change that app’s title, introduction, theme and layout. Uncheck it to use the shared values.

The preview and exported version 2 spec resolve the same settings. Older version 1 drafts keep their shared values when reopened; changed source contracts require a review instead of silently changing their meaning. Each separate group contains all supported fields.

For the existing verified operator pair, pnpm compose --spec PATH --apply-settings verifies the source and owner connection, applies only settings, and confirms the response. It preserves collections and source pins. The agent then checks the standalone and composed views. New customer targets remain work to complete. The separate content and form builder now authors typed fields, groups, optional conditions and bounded repeaters, with model and native EmDash seed exports. Applying those models to a customer app still requires an authorised agent implementation and verification.

Turn the reference into a first app.

Choose Hello in Init, enter a title and introduction, choose a theme and export the specification. Your agent uses pnpm init:hello to inspect the proposed configuration, then explicitly applies it after the same Get Ready checks. A personal private starter uses its explicit repository and already verified workers.dev address; temporary-address intent creates no new target.

The command prepares only the local configuration. Your agent reviews the diff, commits and pushes through the independent repository’s release path, deploys and verifies the changed page. A failed readiness check leaves the configuration untouched.

The maintained authored Hello path uses its existing authorised hostname. The supported private starter accepts only these three fields and the prepared workers.dev profile; its update checks the actual previous source and active Worker version. First accounts, new preview provisioning, arbitrary fork source and cleanup remain separate work. Gallery layout does not apply to Hello.

Let visitors leave a note.

Guestbook owns the short postcard form, private review, approval, media and revocation. Linkarooie can link one exact Guestbook resource and offer that real form only while the source reports it is open. A pending note never appears in a featured card; approval and featuring are separate choices. Closed, paused, full and unavailable states are explained without a send button.

See the local walkthrough · Read the versioned contract and limits

The first composition

Photo Guestbook owns submitted media, moderation and eligibility. Linkarooie owns its card collection. An approved item can be selected and featured; opening its card opens the source contribution. Unavailable, hidden or deleted sources fail closed. Composer joins the routes through Worker service bindings; there are no iframes or private media copies.

Browse the EmDash catalogue · Use the live pair

Update without losing your work

App configuration and owner data live separately from upstream source. A candidate must keep the supported contract and data version, pass capability checks and use exact commits. Incompatible versions or new permissions are rejected before activation. Your working release stays live.

The first path uses explicit, validated promotion through repository commands. Automatic branch following and webhook-driven updates remain unshipped until their concurrency and conflict gates are proven.

Code rollback restores an executable only. It never restores an old database, republishes a hidden image or discards later submissions. Storage exports and backups have their own authorised recovery path.

The supported boundary

This first release is operated by an authorised agent using its own GitHub/Cloudflare runtime. Public users can browse examples, explore decisions and export a spec. They cannot launch arbitrary builds, access production credentials or moderate another owner’s collection.

Owner uploads are capped and invited. No current feature implies a public multi-tenant security guarantee, provider partnership or commercial agreement.

Try fictional encrypted assistant state · Optional Cloudflare dashboard extension · Verified release evidence

Portable assistant context

Carry / forward is an independent assistant-context app. The diagram shows the original concept alongside the current local encryption and disclosure flow.

On your device, a fictional assistant document is encrypted with an owner-held passphrase. You retain the encrypted export. Separately, you review and consent to copying selected memories to a provider. The passphrase never crosses.On your device, a fictional assistant document is encrypted with an owner-held passphrase. You retain the encrypted export. Separately, you review and consent to copying selected memories to a provider. The passphrase never crosses.
The fictional proof: local encryption, separate key ownership and a reviewed clipboard handoff. Editable D2 diagram

You keep the passphrase, reopen the saved export and explicitly choose which memories to copy to a provider.

Server sync, real private data, automated provider connections and key recovery are not verified. Assistant context and a shared game login are separate capabilities.

Try the fictional example · Shared game identity follow-up · Current verified boundary

Check a page’s performance

Add ?vitals=1 to an app’s home page and open “Page performance”. It shows loading, interaction delay and layout shift for that load, using the self-hosted Web Vitals library. Use the app, then read the updated values. They stay in the browser, including on Carry / forward.

The developer console links to public source and app activity. Each app also has /healthz: a small liveness check with its deployed source revision, not a promise that storage and every user flow work. The app leaderboard counts public opens and selected completed actions separately.

Cloudflare’s existing public-page analytics is a separate operator view. A single local reading does not establish the 75th-percentile field result across phone and desktop visitors. Read the current Web Vitals guidance.

Check the project you will build.

Open your project report in Get Ready to read existing instructions, preserved skills and remaining gaps. It stays on your device; the fictional example shows how to read it. Imported metadata never verifies readiness.

A verified Hello folder does not verify your next project. Before changing an EmDash site or plugin, ask the agent to inspect that selected folder’s declarations, guidance and project-local skills.

pnpm ready --inspect-project /absolute/selected/project --purpose emdash-site

Independent consumers use get-ready --inspect-project or the same inspectProject API. The optional local MCP exposes get_ready_project when its host selects --project-purpose emdash-site. The model cannot choose another folder or turn this into installation.

The report distinguishes an absent entrypoint, a reviewed entrypoint match, a different copy to preserve and a file that could not be safely read. It reads fixed metadata only, runs no project code or network requests and changes no files. The report separates the declared EmDash dependency from bounded project-local package metadata on disk. It never imports that code. External/shared links and changing files stay intact for agent review; older reports keep installation unknown. Neither a version on disk nor an entrypoint match verifies compatibility, references, agent discovery, a working build or readiness.

Check the agent’s existing user/plugin skills before adding a project copy. Older scaffolds and authored guidance stay intact. A diagram tool is relevant when the project needs diagrams; WordPress porting skills are relevant to a migration. This diagnostic does not install either or certify readiness. Keep its metadata report private. Official EmDash skill guidance and the standalone API instructions explain the boundary.

Prepare the starter’s local tools.

After your agent fetches Hello, its MCP host can explicitly enable preparation of the reviewed Astro/Wrangler dependencies in that checkout. The agent uses the same Get Ready installer as the command-line journey, verifies existing tools first and installs only when needed. Scripts and hooks stay disabled.

This local preparation does not connect accounts, create ownership, change DNS or deploy. A failed or cancelled attempt stays available for inspection; an ordinary check never retries it. Host setup and recovery instructions explain the opt-in. The complete CLI journey remains available.

Give your agent the missing site guidance.

After project inspection, ask your agent to prepare missing EmDash skills. The supported operation adds the complete reviewed site-building or plugin-authoring guidance with the CLI skill, references and licence. It chooses site or plugin purpose after inspecting the actual project and task. Existing project, user and parent-folder copies stay intact; skills already available through the agent’s plugin are not requested again.

The agent checks its current skill catalogue first, then supplies that inventory explicitly. This preparation supports an exact declared EmDash 1.2.0, Node 22 or 24 and an active Codex project root. It uses pinned files carried in the Get Ready archive, with no remote installer, global change or cloud operation.

Plugin work uses the same operation with an explicit --skill-purpose emdash-plugin. The default remains site guidance. MCP hosts select this purpose separately from read-only project inspection; a tool call cannot change it. This supports plugin work in an EmDash 1.2.0 project, not an SDK-only repository. Preparing instructions does not install or enable a CMS plugin.

A repeat preserves existing copies. Partial or different copies need inspection. Preparation remains action-required until the selected agent’s discovery and relevant use are checked; installed EmDash compatibility and deployment have separate checks.

Check that your agent can use the guidance
  1. Ask the selected agent to inspect its enabled skills, including plugins, before preparation. It should preserve existing copies.
  2. After preparation, open a fresh task in that same project and ask it to confirm that the site-building and EmDash CLI skills are available.
  3. Ask it to use those skills for a read-only review of your collection and public page, checking current official documentation and the installed CLI help. Keep publication and other writes as separate actions.

This path was exercised with fictional content using native Codex CLI 0.145.0 on 14 October 2026. Both prepared skills were discovered and used; the review preserved project source and saved agent configuration. Desktop/IDE discovery, other agents and a customer deployment need their own checks.

The optional local MCP can run the same preparation when its host explicitly enables it and supplies the checked skill inventory. Host setup and recovery instructions explain the supported path.

CLI content creation publishes by default; use its --draft flag for a draft. The tested EmDash 1.2.0 help banner reported v0.0.0, so your agent must inspect installed package metadata rather than trusting that banner as version evidence.

Library and CLI operation · Official EmDash skills

Turn a field model into a local EmDash site.

In Init’s content builder, edit a pattern and open “Create a new EmDash site from these fields”. Copy its request to your authorised agent. The reviewed recipe creates a new source project with the model, a native CMS schema, a published collection with individual entry pages, Tailwind styles, dark/light themes, licences and a frozen dependency lockfile.

pnpm init:site --model EXPORTED_MODEL.json --destination /absolute/parent/new-site

Open an entry’s title to read its own page and copy its address. Title changes keep the same address; unpublished or missing entries return 404. The destination must be absent and its canonical parent must already exist. Existing or partial projects stay intact. The command creates source only: it does not install packages, run a project, connect accounts or deploy. The agent reviews the source, checks relevant Get Ready capabilities and existing skills, then installs the pinned dependencies and verifies the local app.

New sites use EmDash 1.5. After verifying the deployment, set its HTTPS Site URL in EmDash General settings and choose Go live when you want the public site indexed. Draft previews and requests on other origins retain the noindex guard.

Calendar dates in the model keep a day unchanged across timezones. The generated editor uses a date picker, the native schema rejects impossible days and the public page writes the month out. The standalone seed has the same validation with its host’s string editor. Dates are top-level fields only; this does not add timezones, event scheduling or automatic publishing.

The local server binds to localhost; use that hostname for passkeys, rather than a numeric IP. EmDash uses separate simulated D1/R2 storage, applies the schema and provides its native owner setup/editor. Add drafts and explicitly publish entries to show them on the page; no sample account or content is inserted. Longer collections have previous/next links above and below each 20-entry page; bookmarks and browser history work without JavaScript. The first always-visible choice field supplies a native filter—for example, workshop format or directory category. Apply a filter, follow its pages or clear it without JavaScript; the selected choice stays in the address. Public requests show published entries. Native edit and preview requests retain their noindex protection. Optional display conditions apply to the content view, while the native editor shows its CMS fields.

Try owner setup, a draft and publication
  1. Open the printed localhost address followed by /_emdash/admin. Set the site title and owner details, then create a passkey through your browser.
  2. When EmDash shows Passkey created, select Open the dashboard. If asked to sign in, use Sign in with Passkey. Complete the welcome screen.
  3. Choose your collection’s shortcut on the dashboard. Fill an entry and select Save. The public page should still show no entry.
  4. Select Publish now and confirm in the dialog. Refresh the public page to see the entry. Later edits saved as drafts leave the live version visible until you select and confirm Publish changes.

Owner setup, passkey sign-in, draft exclusion and publication were exercised with a virtual authenticator and fictional records in an isolated local project on 14 October 2026. This does not verify a physical credential manager, production authentication or a customer deployment. The local passkey is bound to localhost.

This is a content site with authenticated editing, not a public enquiry/submission form. The local D1 ID and resource names are placeholders. Deployment refuses until the agent supplies the project’s reviewed release path; source ownership, actual account/domain, admin protection, app-owned storage, backup, cost and metadata need separate verification. No real customer deployment is claimed.

Review the project template · Official EmDash Cloudflare guide