source: demo-kit/README.md · generated — edit the markdown, not this file

Client demo kit

Everything needed to show Empire Teas the capture app and the CRM with realistic-looking data, from a laptop, over a shared screen. Built for the demo of 2026-11-10; reuse it for later demos.

Every company, person, email and web address in this kit is fictional. Each web domain was checked as unregistered (no DNS records) on 2026-11-10. Re-check before reusing it much later (dig +short NS <domain> must print nothing), because a domain can be registered at any time.

Not a design reference

The kit’s capture-app demo runs the POC’s own screens with prepared results. It stands in for the capture app in a demo until the real one (forge-et-pwa, F36) runs on dev; from then on, demos show the real app on dev. The design forge-et-pwa is built to is the current capture-app prototype, .forge/design/prototypes/pwa-current/, with its screenshots — never this kit.

So the kit is not updated when the prototype or the capture app changes. Its theme follows the prototype on its own (crm-theme.mjs reads it from the built prototype page), and nothing else in it needs to. Everything in the kit is kept, also once the real app is on dev (Tharinda, 2026-11-13): the capture-app demo stays as the record of the 10 November demo, the sample cards in cards/ still serve to show and test the real app’s card reading, and the CRM data and loader serve any CRM demo.

What is in it

File What it does
start.sh, stop.sh Start and stop the capture-app demo: the POC’s API with prepared results on port 8000, and its web app on http://localhost:5180
demo_main.py Runs the POC’s API unchanged, with three of its mock adapters swapped for prepared results: card reading, web research and scoring
demo_data.py The prepared cards, research, scores, the campaign and the pre-show exhibitor list
seed.py Creates the campaign, imports the exhibitor list and captures two cards ahead of the meeting (start.sh runs it)
vite.demo.mjs Serves the POC’s web app over plain HTTP on localhost, so no certificate warning shows on the shared screen; the camera still works on localhost
crm-theme.mjs Shows the POC’s web app in the CRM’s theme, as the current capture-app prototype (version 2) draws it: it reads the colours, Inter and the Empire Teas logo from .forge/design/prototypes/pwa-current/pwa-prototype.html and patches the POC’s source as Vite serves it — light mode only, the Empire Teas brand, the score bands in the CRM’s status tones. node demo-kit/crm-theme.mjs --check <forge-et-pwa-poc> checks every patch still applies without starting anything
render_cards.py, cards/: Palmgate, Thornbury & Vale, Steppe Leaf, Brightline, two-card pile The five sample card images, and the script that draws them (Chrome headless)
crm-demo-data.js, crm-loader.js 25 accounts with contacts and notes, 25 leads and 8 follow-ups, loaded into the CRM through its own API as the signed-in user
serve-kit.mjs Serves the two CRM files on http://localhost:8770 so a CRM browser tab can load them

Nothing here changes the POC, forge-et-be or forge-et-fe. Runtime logs go to logs/ (gitignored).

The capture-app demo

Needs the POC checkout beside the harness, installed once (/et-run-pwa-poc installs it).

demo-kit/start.sh

The app shows the CRM’s theme, matching version 2 of the capture-app prototype. To show the POC’s own dark and green LeadScout look instead (version 1), start it with demo-kit/start.sh --poc-theme. If the POC’s source has changed so that a theme patch no longer applies, the web app stops at start and logs/web.log names the patch; --poc-theme still works.

The screens are the POC’s own, so this demo does not show the flows agreed on 2026-11-12 (Microsoft sign-in, review before the CRM, Submit for Research, booth visit notes). Show those from the prototype itself, .forge/design/prototypes/pwa-current/pwa-prototype.html, which needs no server.

Open http://localhost:5180. Two leads are already captured, and the Plan screen lists seven exhibitors once the “Gulfood 2027 — Dubai” campaign is chosen at the top.

In the meeting: Capture → Choose from camera roll → pick a card from demo-kit/cards/. The lead shows as researching for a few seconds, then fills in with its score. card-1-palmgate.jpg comes back hot and is matched to its booth on the Plan screen; pile-harbourline-maple.jpg in Scan a pile mode splits into two leads; scanning the same card twice shows the duplicate check.

Say that these are prepared examples, not live AI. The kit returns prepared results for the five sample images; any other image reads as “Unrecognised card”. The real capture app (F36) reads cards with Claude on Bedrock. Stop with demo-kit/stop.sh.

The CRM with realistic data

The same companies appear as CRM leads, so “captured at the show, then a lead in the CRM” is one story.

node demo-kit/serve-kit.mjs     # leave running while loading

Then, in a browser tab signed in to the CRM (dev at https://dev.crm.empire.lk, or a local CRM at http://localhost:5173), open the developer console and run:

for (const f of ['crm-demo-data.js', 'crm-loader.js']) eval(await (await fetch('http://localhost:8770/' + f)).text());
await etLoadDemo();
  • Who to sign in as. The records are created as the signed-in user, whose display name shows as the Owner everywhere, and the follow-ups land in that user’s Activities. The user needs lead.manage, lead.all, account.manage and account.all.
  • Showing price publishing. The Publish button on Pricing → Weekly Prices shows only to a role holding price.publish, together with buying_standard.view or buying_standard.manage to read the round (forge-et-fe src/features/pricing/PricingRoute.tsx). The seeded IT Admin role holds only the Settings page keys (AD #34, AD #41), so on dev either add those keys to the demo user’s role in Settings → Roles before the meeting (audited), or sign in as a user whose role already publishes. A greyed-out Publish button states its reason, usually that every draft in the sale is marked Can’t publish. A published price can afterwards only be withdrawn, never edited (AD #14), so publish in a sale nobody else is using.
  • What it fixes. Accounts and contacts sort A–Z, and every name in the set starts with A–C, so page 1 shows only these records. Leads sort newest first and are dated in the hours before the load, so run it on the day of the demo. The Pricing standards book sorts by number, so older test standards stay first.
  • Running it twice skips what the browser already created (kept in the tab’s localStorage).
  • Cost on dev. Each lead runs dev’s AI (summary, research, priority): about 75 small Haiku calls for the set, well under one US dollar, and about 25 searches from the Exa credit. A local CRM uses the stub AI, whose text starts "Stub ".

A local CRM as a fallback

On a laptop whose local database is full of test runs, start from an empty one. Move the old one aside so it can be restored after the demo; never delete it.

cd ../forge-et-be
docker compose stop postgres
mv .local/postgres .local/postgres.before-demo-$(date +%F)
docker compose up -d --wait
SERVER_PORT=8081 ./gradlew bootRun        # migrations and the repo's local sample set load on start

Port 8081 leaves 8080 to any other session’s backend. In forge-et-fe, start the frontend against it with the local email-only sign-in (laptop Microsoft sign-in only works with a backend on 8080):

VITE_ENTRA_LAPTOP=false ET_BACKEND_PORT=8081 pnpm dev

Sign in at http://localhost:5173 with administrator.local@empireteas.example in the “Local and test only” box (no password), then load the CRM set as above. To restore the old database afterwards: stop Postgres, move the postgres.before-demo-… folder back to .local/postgres, start it.

What the local CRM shows differently from dev:

  • AI text is the stub’s. Lead summaries read “Stub summary: …”, because the local profile has no Bedrock. Show AI output on dev.
  • Pricing shows the repo’s local sample set, with two warnings at the top (a sale whose round is not published, and prices from before it that have not ended, because the daily price sweep does not run locally). Show Pricing on dev.

While the local CRM is up for a demo, run no Playwright test without E2E_GATE=1. Outside the gate, Playwright uses localhost:5173 and reuses whatever app is already serving there, so its fixtures are written into the demo’s database. On 2026-11-10 a triage run did exactly that, and the database had to be rebuilt and the CRM set reloaded. With E2E_GATE=1 it serves its own build on port 15173 (.forge/guides/test-runs-explained.md § The nightly full run).

Before the meeting

Start everything at least an hour before, then open each address and check it shows data:

What Address Started by
Local CRM http://localhost:5173 (backend on 8081) § A local CRM as a fallback
Capture-app demo http://localhost:5180 (API on 8000) demo-kit/start.sh
Current CRM prototype http://localhost:8097/crm-prototype.dc.html the crm-current entry in .claude/launch.json
Current capture-app prototype http://localhost:8766/pwa-prototype.html the pwa-current entry in .claude/launch.json

A restart of Docker Desktop stops the local CRM’s Postgres and LocalStack containers, and the backend on 8081 stops with them, while the two web apps keep running and show nothing. The data is kept on disk. To bring it back:

cd ../forge-et-be && docker compose up -d --wait
cd ../forge-et-be && SERVER_PORT=8081 ./gradlew bootRun

The capture-app demo keeps its data in memory only. If its API stops, run demo-kit/stop.sh and then demo-kit/start.sh; the seed re-creates the starting state in about 20 seconds. Run the same two scripts after a rehearsal, so the meeting starts with only the two pre-captured leads and card 1 has not been scanned yet (a second scan of a card shows as a duplicate).

After the demo

Stop what the demo started: demo-kit/stop.sh, the CRM frontend and backend, serve-kit.mjs and the prototype servers. Then decide whether to keep the demo database (useful for the next demo) or restore the one moved aside, as above. Keep moved-aside database folders until that decision is made, and delete them only after it.

Generated from demo-kit/README.md by .claude/lib/render-docs-html.js. Markdown is canonical.