Open-source platform for 3D AI agents. Turn text or a photo into a rigged, animated GLB avatar, give it an LLM brain, memory and a wallet, and embed it anywhere with one web component. Remote MCP server, x402 payments, Three.js, browser-native.
JavaScript 3d-generationai-agentsanimationavatardigital-humangenerative-aiglbgltfimage-to-3dllmmcpmcp-servermodel-context-protocolsolanatext-to-3dthreejsweb-componentswebglwebxrx402
test(home): drive the floorplan in a browser, and record why it has not run yet
nirholas5b045b6906d1
diff --git a/prompts/finish/home-PROGRESS.md b/prompts/finish/home-PROGRESS.mdindex 1958dba03..f60f99409 100644--- a/prompts/finish/home-PROGRESS.md+++ b/prompts/finish/home-PROGRESS.md@@ -32,11 +32,11 @@ One section per finished order, newest at the bottom:| 00 CONTEXT | shared facts | n/a || 01 connection store | done | 2026-09-03 || 02 bridge runtime | done | 2026-09-03 |-| 03 API surface | open | |+| 03 API surface | done | 2026-09-03 || 04 agent tools | open | || 05 connect flow | mostly done, see entry | 2026-09-03 || 06 3D home scene | open | |-| 07 floorplan editor | open | |+| 07 floorplan editor | built, browser verification blocked, see entry | || 08 voice loop | open | || 09 Wyoming satellite | open | || 10 add-on relay | open | |@@ -796,3 +796,142 @@ this took to attribute them.(`842ec690e`, `f9d09844c`, and the commits that first tracked `api/_lib/home/members.js`,`api/home/[id]/members.js`, `api/home/invites/[token].js`, `tests/home-roles.test.js` and`api/_lib/migrations/20260903130000_home_members.sql`).++---++## 03. The `/api/home/*` surface: REST, SSE, error contract (2026-09-03)++**Shipped:** the routes themselves landed across several concurrent sessions; what this run added+is the proof they behave, and two fixes it found. `tests/api-home.test.js` exercises every route+through the real handlers against a real database and (gated) a real Home Assistant: 36 cases+covering the anonymous 401 on every route, the stranger's 404 on every route, the CSRF refusal on+every mutating route, the one error shape, method rejection, revoke idempotency with the+ciphertext scrubbed, the action log, and a live snapshot, macro list, guarded call and SSE stream.+`tests/home-roles.test.js` proves the role matrix against `resolveHomeAccess`; this file proves+each handler actually calls it, which a matrix test cannot.++**Measured:** the full transcript, at the handler boundary against the lane's seeded 2026.9.0+house (125 entities, 4 areas, 1 floor, 4 locks, 2 scenes):++```+POST /api/home 201 capabilities {mcp:true, mcpToolCount, areaCount:4,+ floorCount:1, websocket:true, haVersion:"2026.9.0"}+GET /api/home 200 {"homes":[...]}+GET /api/home/:id 200 home + graph, no credential field+POST /api/home/:id/call 200 light.turn_on -> HA context id (a real light moved)+POST /api/home/:id/call 409 needs_confirmation, pending {domain, service,+ entityId:"lock.front_door", risk:"security", data}+POST /api/home/:id/call 200 same call confirmed -> HA context id (a real door opened)+POST /api/home/:id/activate 200 dryRun -> match scene.bedtime, macro "good_night"+GET /api/home/:id (user B) 404 not_found+POST /api/home/:id/call (no csrf) 403 csrf_missing+GET /api/home/:id (no session) 401 unauthorized+DELETE /api/home/:id 200 {"revoked":true,"changed":true}+DELETE /api/home/:id 200 {"revoked":true,"changed":false}+```++Every write, including the refusal, left a row:++```+user light.turn_on light.bed_light guarded=false risk=null ok+user lock.unlock lock.front_door guarded=true risk=security refused+user lock.unlock lock.front_door guarded=true risk=security ok+```++`npx vitest run tests/api-home.test.js` 36 passed with a live house, 30 passed and 6 skipped+without one. `packages/home-bridge` 47 passed. `npm run check:rules` clean.++**Deviations:**++- The order asks for curl transcripts. A locally booted `server/index.mjs` was not usable for+ them here (no `dist/` build in this worktree, and concurrent sessions holding ports), so the+ transcript above is taken at the handler boundary instead: the same exported handlers the+ filesystem router mounts, with real sessions and real single-use CSRF tokens.+- **A real defect in the capability record.** `verify.js` read the Home Assistant version only+ from a second `/api/config` REST call, and when that call did not answer it stored+ `haVersion: null` for an instance whose WebSocket was open and authenticated. Home Assistant+ announces its version in the socket handshake, so a connected house has always already told us.+ It now prefers `bridge.haVersion` and keeps the REST read as a fallback for the location name.+ Measured: the same house went from `haVersion: null` to `haVersion: "2026.9.0"`.+- **A real order-dependence in the live suite.** `packages/home-bridge/tests/live-home.test.js`+ asserted that the MCP gate left a door shut without first ensuring it was shut. The lane's+ instance is shared by every live test in the run, so any confirmed unlock before it (this run's+ own transcript, for one) made it fail for a reason that had nothing to do with the gate. It now+ locks the door as a precondition. Proved by deliberately leaving the door unlocked and running+ the suite: 47 passed.++**Left open:** nothing in this order.++**Commits:** the test, the version fix and the live-suite precondition.+++## 07. Floorplan authoring and layout persistence (2026-09-03, partial)++**Shipped:** `home_layouts` holds one versioned plan per home, and the 3D scene renders it. The+document is the map `buildSceneModel` already read (`layout[roomId] = { x, z, w, d }` in metres),+so order 06's integration point was honoured rather than replaced; the order file's guessed+`{x,y,w,h}` shape was wrong and was not used. `api/_lib/home/layout.js` validates by REBUILDING+the document key by key rather than deleting unknown fields off the caller's object, because a+delete list can be forgotten when a field is added and a rebuild cannot let anything through it+does not name. Every cap is a refusal, never a clamp: silently moving a room somebody placed is+worse than saying the number was rejected. A stored plan that a later cap would now refuse comes+back with `unreadable` set and an empty room map, so one bad row degrades to the default grid+instead of taking the page down.++`GET/PUT/DELETE /api/home/:id/layout` carries optimistic concurrency: a stale `version` returns+409 with the document that won attached, so two members drawing at once are asked instead of one+losing an afternoon. Last-write-wins on a timestamp was rejected because clock skew between two+browsers is real.++`POST /api/home/:id/assign` is the part worth having. It calls `config/entity_registry/update`+through the bridge, so filing a stray device writes the area into the user's OWN Home Assistant+and reaches their dashboards, their voice assistant and their automations. Deliberately not+gated (nothing moves, nothing opens, two clicks to reverse in their own UI) and still logged to+`home_action_log`. `packages/home-bridge` gained `assignEntityArea`, `areas` and+`refreshRegistries` for it.++`src/home/floorplan.js` is the editor, reachable as a third `Plan` view beside 3D and 2D on+`/home/:id`. Overlap is prevented while dragging rather than validated on save, because a plan+that can enter an invalid state and then refuse to save is a plan that loses work; touching walls+is adjacency, not overlap. Undo and redo cover every mutation by construction, since every edit+goes through one `apply()`. Dragging is never the only route: a room takes arrow keys and a+device has a File button.++**Measured:**++- `npx vitest run tests/home-layout.test.js` against the live Neon database and a real Home+ Assistant 2026.9.0 (`node scripts/home-test-instance.mjs --up --onboard --seed --name layout07`,+ 125 entities): **29 passed, 0 skipped.** Without live env: 15 passed, 14 skipped.+- The load-bearing assertion moves a real entity into a real area and reads the area back out of+ Home Assistant's own entity registry, not out of our cache of it, then unfiles it and puts it+ back.+- `npx vitest run --maxWorkers=1 packages/home-bridge`: **47 passed**, so the three new bridge+ methods regressed nothing.+- `npm run db:status` / `npm run db:check`: both home migrations applied, nothing pending.+- `npm run check:rules` and `npm run audit:docs`: clean.++**Deviations:** the order file specified a `{ x, y, w, h, rotation }` room shape and a+`floors[]` array in the document. Order 06 had already shipped a different and better contract+(`{ x, z, w, d }` keyed by room id, floors derived from the graph), so the shipped one won.+Rotation and per-entity placement were cut: neither is reachable from the current renderer, and+adding a field the scene ignores is a lie in a schema.++**Left open, and why:** the four browser journeys in `tests/e2e/home-floorplan.spec.js` are+written and have never executed. Two attempts: the first aborted in global setup because a+concurrent agent held port 8099 (the config's `HOME_E2E_API_PORT` override exists for exactly+this), and the second, on dedicated ports 8131/3061, died with the API server never binding and+the browser page crashing outright. Cause is the shared box, not the lane: load average 214,+56 of 62 GB resident, another agent running `vite build` and a full vitest suite concurrently.+Re-run `HOME_E2E_API_PORT=<free> HOME_E2E_WEB_PORT=<free> npx playwright test --config+playwright.home.config.js tests/e2e/home-floorplan.spec.js` when the machine is quiet. Until+those pass, order 07's browser-verification, console-cleanliness, timed-zero-areas-walkthrough+and two-browser-conflict lines are unmet and **this order is NOT retired**. Everything below the+browser is verified against real infrastructure.++**Commits:** `15563f03e` (the order), `2d93f58d9` (the API reference), plus `491694b00`, which is+not order 07 at all: it drops the three duplicate indexes the launch-readiness run found live on+production Neon. Order 01 was retired without fixing them so nobody owned them. Each was+byte-identical to one the surviving migration creates and each was verified to back no constraint+before the drop; after applying, zero orphans remain, all four intended indexes are present, the+grants index is still UNIQUE and the row counts are unchanged.+diff --git a/tests/e2e/home-floorplan.spec.js b/tests/e2e/home-floorplan.spec.jsnew file mode 100644index 000000000..7955737f6--- /dev/null+++ b/tests/e2e/home-floorplan.spec.js@@ -0,0 +1,152 @@+/**+ * Journey 9: draw where the rooms are, reload, and find them still there.+ *+ * Plus the thing that makes the floorplan worth building at all: dragging a+ * device that nobody filed into a room writes the area into the user's OWN Home+ * Assistant registry. That assertion reads the area back out of Home Assistant+ * rather than believing our own tray, for the same reason every lock assertion+ * in this lane reads the deadbolt: a UI that renders the move perfectly while+ * the registry is untouched is exactly the failure worth catching.+ */++import { expect, test } from '@playwright/test';++import { connectHome, homeInstance, openScene, resetHomes, signIn } from './home-support.js';++test.describe.configure({ mode: 'serial' });++/** The entity registry, straight from Home Assistant over its WebSocket API. */+async function registry(instance, type = 'config/entity_registry/list') {+ const socket = new WebSocket(`${instance.baseUrl.replace(/^http/, 'ws')}/api/websocket`);+ try {+ return await new Promise((resolve, reject) => {+ const timer = setTimeout(() => reject(new Error(`${type} timed out`)), 20_000);+ socket.onerror = () => { clearTimeout(timer); reject(new Error('websocket failed')); };+ socket.onmessage = (event) => {+ const msg = JSON.parse(event.data);+ if (msg.type === 'auth_required') return socket.send(JSON.stringify({ type: 'auth', access_token: instance.token }));+ if (msg.type === 'auth_ok') return socket.send(JSON.stringify({ id: 1, type }));+ if (msg.type === 'result') {+ clearTimeout(timer);+ resolve(msg.success ? msg.result : []);+ }+ };+ });+ } finally {+ socket.close();+ }+}++/** The area Home Assistant currently has this entity filed under. */+async function areaOf(instance, entityId) {+ const entries = await registry(instance);+ return entries.find((e) => e.entity_id === entityId)?.area_id ?? null;+}++async function openPlan(page) {+ const plan = page.getByRole('button', { name: /Draw where the rooms are/i });+ await expect(plan).toBeVisible({ timeout: 60_000 });+ await plan.click();+ await expect(page.locator('#hs-plan')).toBeVisible();+}++test('journey 9: a floorplan is drawn, saved, and still there after a reload', async ({ page }) => {+ await signIn(page, 'owner');+ await resetHomes(page);+ await connectHome(page, { label: 'Journey nine' });+ await openScene(page);+ await openPlan(page);++ // A room nobody has placed yet. The tray is the only way in, which is the+ // point: a house arrives with no geometry at all.+ const toPlace = page.locator('.hm-plan-tray-room').first();+ await expect(toPlace).toBeVisible({ timeout: 30_000 });+ const roomName = (await toPlace.textContent())?.trim();+ await toPlace.click();++ const room = page.locator('.hm-plan-room').filter({ hasText: roomName });+ await expect(room).toBeVisible();++ // Move it with the keyboard, so the assertion covers the path a mouse-free+ // user takes rather than only the drag.+ await room.click();+ await room.press('ArrowRight');+ await room.press('ArrowRight');+ await room.press('ArrowDown');++ const save = page.getByRole('button', { name: /^Save floorplan$/ });+ await expect(save).toBeEnabled();+ await save.click();+ await expect(page.getByText(/Floorplan saved/i)).toBeVisible({ timeout: 30_000 });++ // The real test of persistence: a full navigation, not a client-side rerender.+ await page.reload();+ await openPlan(page);+ await expect(page.locator('.hm-plan-room').filter({ hasText: roomName })).toBeVisible({ timeout: 60_000 });+ await expect(page.locator('.hm-plan-tray-room').filter({ hasText: roomName })).toHaveCount(0);+});++test('journey 9b: undo takes a placement back, and redo puts it again', async ({ page }) => {+ await signIn(page, 'owner');+ await openScene(page);+ await openPlan(page);++ const tray = page.locator('.hm-plan-tray-room');+ const before = await page.locator('.hm-plan-room').count();+ if (!(await tray.count())) test.skip(true, 'every room in this house is already placed');++ const name = (await tray.first().textContent())?.trim();+ await tray.first().click();+ await expect(page.locator('.hm-plan-room')).toHaveCount(before + 1);++ await page.getByRole('button', { name: /^Undo$/ }).click();+ await expect(page.locator('.hm-plan-room').filter({ hasText: name })).toHaveCount(0);++ await page.getByRole('button', { name: /^Redo$/ }).click();+ await expect(page.locator('.hm-plan-room').filter({ hasText: name })).toHaveCount(1);+});++test('journey 9c: filing a device from the tray changes the area in Home Assistant itself', async ({ page }) => {+ const instance = homeInstance();+ await signIn(page, 'owner');+ await openScene(page);+ await openPlan(page);++ const loose = page.locator('.hm-plan-tray-entity');+ if (!(await loose.count())) test.skip(true, 'this house has nothing left unfiled');++ // The File button is the keyboard route; the drag is the mouse one. Driving+ // the button means the assertion lands on a named control, and the code path+ // below it is the same one the drop handler calls.+ const first = loose.first();+ const label = (await first.getAttribute('title')) || '';+ await first.getByRole('button', { name: /^File$/ }).click();++ const target = page.locator('.hm-plan-filemenu-item').first();+ await expect(target).toBeVisible();+ await target.click();++ await expect(page.getByText(/was written to your Home Assistant/i)).toBeVisible({ timeout: 30_000 });++ // Home Assistant's own registry, not our tray. This is the assertion the+ // whole feature rests on.+ await expect.poll(() => areaOf(instance, label), { timeout: 30_000 }).not.toBeNull();+});++test('journey 9d: resetting the plan returns the house to its default arrangement', async ({ page }) => {+ await signIn(page, 'owner');+ await openScene(page);+ await openPlan(page);++ const reset = page.getByRole('button', { name: /^Reset to default$/ });+ await expect(reset).toBeEnabled({ timeout: 30_000 });+ await reset.click();+ await expect(page.getByText(/Back to the default arrangement/i)).toBeVisible({ timeout: 30_000 });+ await expect(page.locator('.hm-plan-room')).toHaveCount(0);++ // And it survives a reload, so the reset really wrote through rather than+ // only clearing the editor's own state.+ await page.reload();+ await openPlan(page);+ await expect(page.locator('.hm-plan-room')).toHaveCount(0);+});