mirror of
https://github.com/Ark0N/Codeman.git
synced 2026-09-30 12:39:42 +02:00
feat: vendor gesture-control source into packages/gesture-control
Bring the Ark0N/codeman-gesture-control repo in-tree as the codeman-gesture-control workspace package so the hand-tracking overlay can be developed in the Codeman repo. New npm run build:gesture bundles src/codeman/entry.ts into the served gesture-codeman.js; scripts/build.mjs reruns it on every production build. Source formatted to Codeman's prettier style. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
This commit is contained in:
arkon
+8
-1
@@ -61,10 +61,17 @@ tmp/
|
||||
|
||||
# Opt-in gesture overlay runtime assets: large MediaPipe wasm + model (~27 MB)
|
||||
# fetched at build/install by scripts/fetch-gesture-assets.mjs, kept out of git.
|
||||
# (The gesture bundle itself, gesture-codeman.js, IS tracked.)
|
||||
# (The gesture bundle itself, gesture-codeman.js, IS tracked — built from
|
||||
# packages/gesture-control source by `npm run build:gesture`.)
|
||||
src/web/public/gesture/wasm/
|
||||
src/web/public/gesture/*.task
|
||||
|
||||
# Gesture-control workspace package build outputs (source is tracked; the
|
||||
# Codeman bundle is emitted to src/web/public/gesture/gesture-codeman.js instead).
|
||||
packages/gesture-control/dist/
|
||||
packages/gesture-control/dist-codeman/
|
||||
packages/gesture-control/.vite/
|
||||
|
||||
# Claude Code plan tracking
|
||||
plan.json
|
||||
|
||||
|
||||
@@ -1,5 +1,17 @@
|
||||
# aicodeman
|
||||
|
||||
## 0.9.2
|
||||
|
||||
### Patch Changes
|
||||
|
||||
- Vendor the gesture-control source into the repo for in-tree development.
|
||||
|
||||
The hand-tracking overlay's source (previously the standalone `Ark0N/codeman-gesture-control` repo) now lives at `packages/gesture-control/` as the `codeman-gesture-control` workspace package: the transport-agnostic gesture core (`src/gesture/*` — MediaPipe GestureRecognizer → One-Euro-filtered cursor → pinch state machine), the Codeman consumer entry (`src/codeman/entry.ts`, maps grab/drag/drop onto real session tabs + toolbar buttons), and a standalone vite playground for iterating on gesture feel.
|
||||
- New `npm run build:gesture` (`scripts/build-gesture-bundle.mjs`) esbuild-bundles `entry.ts` into the served `src/web/public/gesture/gesture-codeman.js`; `scripts/build.mjs` now reruns it on every production build so the served bundle always reflects current source. The MediaPipe wasm + model stay runtime-loaded from same-origin `/gesture/` (unchanged).
|
||||
- Added `@mediapipe/tasks-vision@0.10.21` as the package dependency (kept in sync with `fetch-gesture-assets.mjs`). The playground uses vite 7 (no known advisories).
|
||||
|
||||
No change to the shipped app behavior — gesture control remains opt-in (`CODEMAN_GESTURE=1` + the App Settings → Input toggle). This release just makes the overlay developable inside the Codeman repo.
|
||||
|
||||
## 0.9.1
|
||||
|
||||
### Patch Changes
|
||||
|
||||
@@ -56,7 +56,7 @@ When user says "COM":
|
||||
|
||||
CI runs `npm run check:lockfile` on every push/PR, so lockfile drift fails the build even if the `version-packages` script is bypassed.
|
||||
|
||||
**Version**: 0.9.1 (must match `package.json`)
|
||||
**Version**: 0.9.2 (must match `package.json`)
|
||||
|
||||
## Project Overview
|
||||
|
||||
@@ -82,6 +82,8 @@ Codeman is a Claude Code session manager with web interface and autonomous Ralph
|
||||
| Continuous typecheck | `tsc --noEmit --watch` |
|
||||
| Test coverage | `npm run test:coverage` |
|
||||
| Dead-code sweep | `npm run knip` (config in `knip.json`) |
|
||||
| Rebuild gesture overlay | `npm run build:gesture` (esbuild `packages/gesture-control/src/codeman/entry.ts` → `src/web/public/gesture/gesture-codeman.js`; commit the result) |
|
||||
| Gesture playground | `npm run dev` **in** `packages/gesture-control/` (standalone vite demo, fake tabs) |
|
||||
| Check public-asset formatting | `npm run check:public-assets` (prettier-checks `src/web/public/**` text assets; `scripts/check-public-assets.mjs`) |
|
||||
| Production start | `npm run start` |
|
||||
| Production logs | `journalctl --user -u codeman-web -f` |
|
||||
@@ -130,7 +132,7 @@ Codeman is a Claude Code session manager with web interface and autonomous Ralph
|
||||
|
||||
★ = Large file (>50KB). All files have `@fileoverview` JSDoc — read that before diving in. Discovery aid: `grep -l '@fileoverview' src/web/routes/*.ts` lists all route modules; same grep works for `src/types/`, `src/web/public/*.js`.
|
||||
|
||||
**Local package**: `packages/xterm-zerolag-input/` — local echo overlay for xterm.js; copy embedded in `app.js`.
|
||||
**Local packages**: `packages/xterm-zerolag-input/` — local echo overlay for xterm.js; copy embedded in `app.js`. `packages/gesture-control/` (`codeman-gesture-control`) — hand-tracking overlay source; built to `src/web/public/gesture/gesture-codeman.js` via `npm run build:gesture` (see Frontend → Gesture control).
|
||||
|
||||
**Config**: `src/config/` — 10 files. Import from specific files, not barrel.
|
||||
|
||||
@@ -169,6 +171,8 @@ Frontend JS modules have `@fileoverview` with `@dependency`/`@loadorder` tags. L
|
||||
|
||||
**Gesture control** (the camera hand-tracking overlay) is **opt-in, default OFF**, under App Settings → Display → **Input** (`gestureControlEnabled`). `CODEMAN_GESTURE=1` makes the feature *available* on the instance (CSP widening + `/gesture/` assets) and sets `window.__codemanGestureAvailable` (the Input section only shows when set); the overlay bundle is injected by `renderIndexHtml` **only when the setting is enabled**, so that method is `async` and reads `settings.json` via `readSettings(true)` — the `true` forces a **fresh** read (bypassing the 2s `_settingsCache`), because a post-save reload happens within that TTL and the cached value would otherwise render the pre-toggle state. Toggling the setting reloads the page (the bundle is render-injected).
|
||||
|
||||
**Gesture-control source lives in-repo** at `packages/gesture-control/` (workspace package `codeman-gesture-control`, was the standalone `Ark0N/codeman-gesture-control` repo). The transport-agnostic core is `src/gesture/*` (MediaPipe GestureRecognizer → One-Euro-filtered cursor → pinch state machine); `src/codeman/entry.ts` is the Codeman *consumer* that maps grab/drag/drop onto real `.session-tab`/toolbar buttons and is the bundle entry. **Edit there, then run `npm run build:gesture`** (`scripts/build-gesture-bundle.mjs` → esbuild bundles `entry.ts`, MediaPipe JS included, into `src/web/public/gesture/gesture-codeman.js`) and **commit the regenerated bundle** — the committed bundle is what dev/`tsx` serves (no bundler at runtime), and `scripts/build.mjs` reruns the same step so prod always reflects current source. The MediaPipe **wasm + model** are NOT bundled — loaded at runtime from same-origin `/gesture/wasm` + `/gesture/gesture_recognizer.task`, fetched by `scripts/fetch-gesture-assets.mjs` (gitignored, see Gotchas). `entry.ts` mounts `window.__codemanGesture = new GestureBridge()` idempotently at module-eval. A standalone vite playground (`npm run dev` in the package — fake tabs, no Codeman) lets you iterate on gesture *feel* in isolation. ⚠️ Keep `MP_VERSION` in `fetch-gesture-assets.mjs` in sync with `@mediapipe/tasks-vision` in `packages/gesture-control/package.json`.
|
||||
|
||||
**Respawn presets**: `solo-work` (3s/60min), `subagent-workflow` (45s/240min), `team-lead` (90s/480min), `ralph-todo` (8s/480min), `overnight-autonomous` (10s/480min).
|
||||
|
||||
**Keyboard shortcuts**: Escape (close), Ctrl+? (help), Ctrl+W (kill), Ctrl+Tab (next), Alt+1-9 (switch tab), Ctrl+Shift+{/} (move tab left/right), Shift+Enter (newline), Ctrl+L (clear), Ctrl+Shift+R (restore size), Ctrl+Shift+V (voice input), Ctrl/Cmd +/- (font).
|
||||
|
||||
Generated
+130
-2
@@ -1,12 +1,12 @@
|
||||
{
|
||||
"name": "aicodeman",
|
||||
"version": "0.9.1",
|
||||
"version": "0.9.2",
|
||||
"lockfileVersion": 3,
|
||||
"requires": true,
|
||||
"packages": {
|
||||
"": {
|
||||
"name": "aicodeman",
|
||||
"version": "0.9.1",
|
||||
"version": "0.9.2",
|
||||
"hasInstallScript": true,
|
||||
"license": "MIT",
|
||||
"workspaces": [
|
||||
@@ -1753,6 +1753,12 @@
|
||||
"mediabunny": "^1.0.0"
|
||||
}
|
||||
},
|
||||
"node_modules/@mediapipe/tasks-vision": {
|
||||
"version": "0.10.21",
|
||||
"resolved": "https://registry.npmjs.org/@mediapipe/tasks-vision/-/tasks-vision-0.10.21.tgz",
|
||||
"integrity": "sha512-TuhKH+credq4zLksGbYrnvJ1aLIWMc5r0UHwzxzql4BHECJwIAoBR61ZrqwGOW6ZmSBIzU1t4VtKj8hbxFaKeA==",
|
||||
"license": "Apache-2.0"
|
||||
},
|
||||
"node_modules/@module-federation/error-codes": {
|
||||
"version": "0.22.0",
|
||||
"resolved": "https://registry.npmjs.org/@module-federation/error-codes/-/error-codes-0.22.0.tgz",
|
||||
@@ -5334,6 +5340,10 @@
|
||||
"node": ">=12"
|
||||
}
|
||||
},
|
||||
"node_modules/codeman-gesture-control": {
|
||||
"resolved": "packages/gesture-control",
|
||||
"link": true
|
||||
},
|
||||
"node_modules/color-convert": {
|
||||
"version": "2.0.1",
|
||||
"resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz",
|
||||
@@ -12166,6 +12176,124 @@
|
||||
"url": "https://github.com/sponsors/colinhacks"
|
||||
}
|
||||
},
|
||||
"packages/gesture-control": {
|
||||
"name": "codeman-gesture-control",
|
||||
"version": "0.1.0",
|
||||
"dependencies": {
|
||||
"@mediapipe/tasks-vision": "0.10.21"
|
||||
},
|
||||
"devDependencies": {
|
||||
"esbuild": "^0.27.3",
|
||||
"typescript": "^5.5.4",
|
||||
"vite": "^7.3.5"
|
||||
}
|
||||
},
|
||||
"packages/gesture-control/node_modules/fdir": {
|
||||
"version": "6.5.0",
|
||||
"resolved": "https://registry.npmjs.org/fdir/-/fdir-6.5.0.tgz",
|
||||
"integrity": "sha512-tIbYtZbucOs0BRGqPJkshJUYdL+SDH7dVM8gjy+ERp3WAUjLEFJE+02kanyHtwjWOnwrKYBiwAmM0p4kLJAnXg==",
|
||||
"dev": true,
|
||||
"license": "MIT",
|
||||
"engines": {
|
||||
"node": ">=12.0.0"
|
||||
},
|
||||
"peerDependencies": {
|
||||
"picomatch": "^3 || ^4"
|
||||
},
|
||||
"peerDependenciesMeta": {
|
||||
"picomatch": {
|
||||
"optional": true
|
||||
}
|
||||
}
|
||||
},
|
||||
"packages/gesture-control/node_modules/picomatch": {
|
||||
"version": "4.0.4",
|
||||
"resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.4.tgz",
|
||||
"integrity": "sha512-QP88BAKvMam/3NxH6vj2o21R6MjxZUAd6nlwAS/pnGvN9IVLocLHxGYIzFhg6fUQ+5th6P4dv4eW9jX3DSIj7A==",
|
||||
"dev": true,
|
||||
"license": "MIT",
|
||||
"engines": {
|
||||
"node": ">=12"
|
||||
},
|
||||
"funding": {
|
||||
"url": "https://github.com/sponsors/jonschlinkert"
|
||||
}
|
||||
},
|
||||
"packages/gesture-control/node_modules/vite": {
|
||||
"version": "7.3.5",
|
||||
"resolved": "https://registry.npmjs.org/vite/-/vite-7.3.5.tgz",
|
||||
"integrity": "sha512-KuOaNhcnGFN2zIPGA7wRmzF+lJA1sea7rHq17aiJ++9lzY1WWG6Jpwqwe1KNbRVPIqHmr8GLYx7jbrQcN/7/ww==",
|
||||
"dev": true,
|
||||
"license": "MIT",
|
||||
"dependencies": {
|
||||
"esbuild": "^0.27.0",
|
||||
"fdir": "^6.5.0",
|
||||
"picomatch": "^4.0.3",
|
||||
"postcss": "^8.5.6",
|
||||
"rollup": "^4.43.0",
|
||||
"tinyglobby": "^0.2.15"
|
||||
},
|
||||
"bin": {
|
||||
"vite": "bin/vite.js"
|
||||
},
|
||||
"engines": {
|
||||
"node": "^20.19.0 || >=22.12.0"
|
||||
},
|
||||
"funding": {
|
||||
"url": "https://github.com/vitejs/vite?sponsor=1"
|
||||
},
|
||||
"optionalDependencies": {
|
||||
"fsevents": "~2.3.3"
|
||||
},
|
||||
"peerDependencies": {
|
||||
"@types/node": "^20.19.0 || >=22.12.0",
|
||||
"jiti": ">=1.21.0",
|
||||
"less": "^4.0.0",
|
||||
"lightningcss": "^1.21.0",
|
||||
"sass": "^1.70.0",
|
||||
"sass-embedded": "^1.70.0",
|
||||
"stylus": ">=0.54.8",
|
||||
"sugarss": "^5.0.0",
|
||||
"terser": "^5.16.0",
|
||||
"tsx": "^4.8.1",
|
||||
"yaml": "^2.4.2"
|
||||
},
|
||||
"peerDependenciesMeta": {
|
||||
"@types/node": {
|
||||
"optional": true
|
||||
},
|
||||
"jiti": {
|
||||
"optional": true
|
||||
},
|
||||
"less": {
|
||||
"optional": true
|
||||
},
|
||||
"lightningcss": {
|
||||
"optional": true
|
||||
},
|
||||
"sass": {
|
||||
"optional": true
|
||||
},
|
||||
"sass-embedded": {
|
||||
"optional": true
|
||||
},
|
||||
"stylus": {
|
||||
"optional": true
|
||||
},
|
||||
"sugarss": {
|
||||
"optional": true
|
||||
},
|
||||
"terser": {
|
||||
"optional": true
|
||||
},
|
||||
"tsx": {
|
||||
"optional": true
|
||||
},
|
||||
"yaml": {
|
||||
"optional": true
|
||||
}
|
||||
}
|
||||
},
|
||||
"packages/xterm-zerolag-input": {
|
||||
"version": "0.1.4",
|
||||
"license": "MIT",
|
||||
|
||||
+2
-1
@@ -1,6 +1,6 @@
|
||||
{
|
||||
"name": "aicodeman",
|
||||
"version": "0.9.1",
|
||||
"version": "0.9.2",
|
||||
"description": "The missing control plane for AI coding agents - run 20 autonomous agents with real-time monitoring and session persistence",
|
||||
"type": "module",
|
||||
"main": "dist/index.js",
|
||||
@@ -11,6 +11,7 @@
|
||||
"scripts": {
|
||||
"postinstall": "node scripts/postinstall.js",
|
||||
"build": "node scripts/build.mjs",
|
||||
"build:gesture": "node scripts/build-gesture-bundle.mjs",
|
||||
"start": "NODE_COMPILE_CACHE=${HOME}/.codeman/compile-cache node dist/index.js",
|
||||
"dev": "tsx src/index.ts web",
|
||||
"web": "node dist/index.js web",
|
||||
|
||||
@@ -0,0 +1,6 @@
|
||||
node_modules
|
||||
dist
|
||||
dist-codeman/
|
||||
*.local
|
||||
.vite
|
||||
.DS_Store
|
||||
@@ -0,0 +1,258 @@
|
||||
# gesture-proto
|
||||
|
||||
A Jarvis-style hand-tracking input layer for the Codeman dashboard. Your webcam
|
||||
sees your hands; you pinch-drag session tabs between columns. Runs entirely
|
||||
in-browser — **the camera feed never leaves the machine.**
|
||||
|
||||
> **This build is pinch-drag only.** The discrete gesture commands (halt-all /
|
||||
> approve / new-session) were built in Phase 4 but are **intentionally not wired
|
||||
> up** — an open palm while reaching to pinch kept charging the hold-to-halt. The
|
||||
> `GestureController` core still emits `command`/`haltProgress` for any future
|
||||
> consumer; the demo just no longer listens.
|
||||
|
||||
This is a standalone prototype (own folder, fake tabs) so the input *feel* can
|
||||
be validated on real hardware before integrating with Codeman. The canonical
|
||||
spec is **[`docs/BUILD_PLAN.md`](./docs/BUILD_PLAN.md)** — read it before
|
||||
continuing the build.
|
||||
|
||||
---
|
||||
|
||||
## Status: Phase 0–4 complete
|
||||
|
||||
| Phase | What | State |
|
||||
|-------|------|-------|
|
||||
| 0 | Vite+TS scaffold, mirrored webcam preview, start button | ✅ done |
|
||||
| 1 | MediaPipe `GestureRecognizer` (VIDEO mode, CDN model+wasm), rAF loop, debug skeleton overlay, HUD | ✅ done |
|
||||
| — | **Checkpoint: ≥25fps on real camera/lighting** | ✅ 60fps (iPhone 17 Pro / Continuity Camera) |
|
||||
| 2 | One-Euro–filtered cursor + pinch detection (hysteresis) | ✅ done |
|
||||
| 3 | Drag fake tabs across 3 columns (state machine) — go/no-go | ✅ done (two-handed) |
|
||||
| 4 | Discrete gesture→command bus (👍 approve · ✌️ new-session · ✋-hold halt-all) + toast | ✅ built, ⛔ **unwired in the demo** (pinch-only) |
|
||||
| 5 | Integrate `gesture/` into real Codeman (`src/codeman/entry.ts`) | ✅ **working at the desk** — see [Codeman integration](#codeman-integration) |
|
||||
|
||||
Also done beyond the original plan: **two-hand tracking** (drag two tabs at
|
||||
once) and a **live camera picker** (front-facing iPhone 17 Pro by default; the
|
||||
superwide / Desk View camera now works too — see the camera note below).
|
||||
|
||||
Also: **fullscreen mode** (toggle button — the board fills the display, so grab
|
||||
targets get big).
|
||||
|
||||
**Phase 5 is live** in the real Codeman dashboard. The Codeman-side detach +
|
||||
instance isolation + base gesture overlay are committed on `Ark0N/Codeman`
|
||||
branch `beta/session-detach` (open as **PR #103**) — including this session's
|
||||
gesture *improvements* (direct-detach, Run/Run Shell taps, self-hosted MediaPipe,
|
||||
cache-bust), ported onto the PR in commit `eea84db` (CI green). See
|
||||
[Codeman integration](#codeman-integration) below and the hand-off brief
|
||||
[`../docs/CODEMAN_DETACH_BRIEF.md`](../docs/CODEMAN_DETACH_BRIEF.md).
|
||||
|
||||
**Multi-monitor mode — built & validated at the desk (2026-06-08).** Approach
|
||||
**A+C** (see [`../docs/MULTIMONITOR_DESIGN.md`](../docs/MULTIMONITOR_DESIGN.md)):
|
||||
(A) gesture "detach" now pops a session into a re-grabbable **in-page floating
|
||||
panel** (an `<iframe src="/session/:id">`, not an OS window — so the hand keeps
|
||||
control); (C) `scripts/span-codeman.sh` runs Codeman in a **single window spanned
|
||||
across both monitors** (Brave-first; needs macOS "Displays have separate Spaces"
|
||||
OFF + re-login), launchable one-click from a new **multi-monitor button** in
|
||||
Codeman's header. Confirmed: a panel drags across the monitor seam. Still pending:
|
||||
`getScreenDetails` screen-snapping (C-snap) and the re-dock gesture.
|
||||
|
||||
---
|
||||
|
||||
## Run it
|
||||
|
||||
```bash
|
||||
cd gesture-proto
|
||||
npm install
|
||||
npm run dev
|
||||
```
|
||||
|
||||
Open the URL Vite prints (http://localhost:5173). `getUserMedia` requires a
|
||||
secure context — `localhost` qualifies, so the dev server is fine. Click
|
||||
**Start camera**, allow the camera, hold a hand up. You should see each hand's
|
||||
21-point skeleton, a cursor ring per hand (cyan = left, violet = right, green
|
||||
while pinching), and a live HUD.
|
||||
|
||||
**Choosing a camera:** after Start, the dropdown lists every video device. On a
|
||||
Mac with an iPhone nearby (Continuity Camera) you'll typically see the built-in
|
||||
FaceTime cam, the **iPhone Camera** (main/wide lens), and a **Desk View Camera**
|
||||
— the latter is driven by the iPhone's ultra-wide lens aimed down at the desk
|
||||
(the overhead angle). Switching is live; no restart needed. The browser can't
|
||||
select the ultra-wide lens directly, so Desk View is how you reach it. **The
|
||||
Desk View / superwide camera now works with no issues and tracking is confirmed
|
||||
on it** — earlier it was Safari-only and rendered stretched; that's resolved.
|
||||
|
||||
**Using it:** point at a tab (it highlights), **pinch** thumb+index to grab,
|
||||
move to another Screen column, release to drop. Both hands work at once. **⛶
|
||||
Fullscreen** makes the board fill the display (Esc exits). No open-hand gesture
|
||||
commands in this build — it's pinch-drag only (see the note up top).
|
||||
|
||||
Other scripts: `npm run build` (tsc + vite build), `npm run preview`.
|
||||
|
||||
### Developing on the Mac mini, running on the MacBook
|
||||
|
||||
The prototype is *run/tested* on the MacBook (better for sitting at the desk
|
||||
with the camera). To sync:
|
||||
|
||||
```bash
|
||||
git pull # on the MacBook
|
||||
cd gesture-proto && npm install && npm run dev
|
||||
```
|
||||
|
||||
No machine-specific state is committed (`node_modules/`, `dist/`, and
|
||||
`.claude/settings.local.json` are gitignored).
|
||||
|
||||
### Framerate note
|
||||
|
||||
The HUD fps turns **green at ≥ 25**, amber below. Confirmed **60fps** on the
|
||||
iPhone 17 Pro (Continuity Camera). If it's ever low, improve **even, frontal
|
||||
lighting on the hand zone** first — that matters more than the sensor.
|
||||
|
||||
---
|
||||
|
||||
## Codeman integration
|
||||
|
||||
Phase 5 ships a **separate consumer**, `src/codeman/entry.ts` (the demo +
|
||||
`main.ts` are untouched — they stay as a desk-testing harness). It imports the
|
||||
same unchanged `src/gesture/` core and binds its events to the **real** Codeman
|
||||
dashboard. Build it standalone (MediaPipe inlined) with:
|
||||
|
||||
```bash
|
||||
npm run build:codeman # esbuild → dist-codeman/gesture-codeman.js
|
||||
```
|
||||
|
||||
Codeman serves that bundle at `/gesture/gesture-codeman.js` and injects it into
|
||||
the dashboard **only when started with `CODEMAN_GESTURE=1`** (which also widens
|
||||
its CSP for WebAssembly). Deploy = copy the bundle into Codeman's
|
||||
`src/web/public/gesture/` and reload (static is served from disk).
|
||||
|
||||
**Gestures (all off one pinch, routed by what's under your fingertips):**
|
||||
- **Fullscreen camera** by default — mirrored, dimmed, full-viewport so you see
|
||||
your hands over the real tabs; the **⛶** button toggles a corner preview.
|
||||
- **Grab → in-page floating panel** *(pivoted 2026-06-08 — replaced the old
|
||||
OS-window detach)* — pinch a session tab, a ghost of it follows your hand, pull
|
||||
it out of the strip (>70px) and release → the session pops into a **re-grabbable
|
||||
in-page `.cg-float` panel** (an `<iframe src="/session/:id">`, 640×420) at the
|
||||
drop point. Pinch the panel again to move it anywhere. It stays inside the
|
||||
camera-owning page, so the hand keeps control (the old `window.app.detachSession`
|
||||
`window.open` was a one-way trip). A small twitch-and-release cancels.
|
||||
- **Run / Run Shell** — pinch over the **Run** (`#runBtn`) or **Run Shell**
|
||||
(`.btn-shell`) toolbar button and release in place to fire it; drifting too
|
||||
far first cancels the tap. The button list is `CLICK_SELECTOR` in `entry.ts`.
|
||||
|
||||
**Self-hosted MediaPipe.** The Codeman consumer loads the wasm runtime + the
|
||||
`gesture_recognizer.task` model **same-origin** from `/gesture/` (via
|
||||
`wasmBase`/`modelUrl` options), not the CDN — a browser content/ad blocker can
|
||||
otherwise block the CDN and startup fails with `failed: {"isTrusted":true}`.
|
||||
|
||||
**Multi-monitor button.** Codeman's header has a **multi-monitor button** (it
|
||||
replaced the notification bell) → `POST /api/system/span-displays` → spawns
|
||||
`scripts/span-codeman.sh`, opening a fresh browser `--app` window spanned across
|
||||
all displays so floating panels can cross the monitor seam (PR #103 `95b0035`).
|
||||
|
||||
**Caveats:** Codeman serves static with a 1-year **`immutable`** cache, so
|
||||
`server.ts` `cacheBustAssets()` appends `?v=<mtime>` to **every** same-origin
|
||||
`.js`/`.css` (and the gesture bundle), re-stat'd per render — without it an edited
|
||||
module stays cached until a hard refresh (PR #103 `b5ea711`). The old OS-window
|
||||
detach verb (kept only as a deliberate, non-default action) does `window.open`,
|
||||
which a pinch can get popup-blocked — allow popups once if you ever wire it back.
|
||||
|
||||
---
|
||||
|
||||
## Layout
|
||||
|
||||
```
|
||||
gesture-proto/
|
||||
├── index.html # demo page: video, tab board, HUD, controls
|
||||
├── docs/
|
||||
│ └── BUILD_PLAN.md # canonical spec: goals, algorithms, phases, tuning
|
||||
├── src/
|
||||
│ ├── main.ts # wires GestureController -> demo UI (board, HUD, camera, fullscreen)
|
||||
│ ├── gesture/
|
||||
│ │ ├── GestureController.ts # camera + recognizer + loop + per-hand state + event bus
|
||||
│ │ ├── OneEuroFilter.ts # per-axis cursor smoothing
|
||||
│ │ ├── pinch.ts # pinch distance + hysteresis detector
|
||||
│ │ ├── commands.ts # debounced gesture→command bus (Phase 4)
|
||||
│ │ ├── landmarks.ts # landmark indices, connections, helpers
|
||||
│ │ └── types.ts # event payload types + config (full API surface)
|
||||
│ ├── demo/
|
||||
│ │ ├── overlay.ts # draws the hand skeleton + per-hand cursors
|
||||
│ │ └── tabs.ts # the 3-column board: hit-testing + drag mechanics
|
||||
│ └── codeman/
|
||||
│ └── entry.ts # Phase 5 Codeman consumer (real tabs + Run/Run Shell);
|
||||
│ # esbuild-bundled by `npm run build:codeman`
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## `GestureController` API
|
||||
|
||||
Transport-agnostic: it owns the camera, recognizer, per-hand smoothing, pinch
|
||||
state machine, and gesture→command bus, and emits **coordinate-only** events. It
|
||||
knows nothing about tabs or the DOM — hit-testing lives in the consumer (the
|
||||
demo's `tabs.ts`, later Codeman). Integration (Phase 5) is just subscribing and
|
||||
calling Codeman's existing tab-move / command functions.
|
||||
|
||||
```ts
|
||||
const gc = new GestureController({
|
||||
video: videoEl,
|
||||
surface: stageEl, // normalized coords map against this element's rect
|
||||
numHands: 2,
|
||||
pinchOn: 0.35, pinchOff: 0.5, // pinch hysteresis (fractions of hand size)
|
||||
minCutoff: 1.0, beta: 0.01, // One-Euro cursor smoothing
|
||||
palmHoldMs: 1000, // Open_Palm hold before halt-all fires
|
||||
deviceId: "", // specific camera; "" = default user-facing
|
||||
});
|
||||
|
||||
// Drag events — surface pixels (X already mirrored), with a per-hand id.
|
||||
gc.on("grab", ({ hand, x, y }) => {}); // pinch closed → start drag
|
||||
gc.on("drag", ({ hand, x, y }) => {}); // moving while pinched (per frame)
|
||||
gc.on("drop", ({ hand, x, y }) => {}); // released (or hand vanished mid-pinch)
|
||||
|
||||
// Discrete commands: "halt-all" | "approve" | "new-session".
|
||||
// Still emitted by the controller, but THIS build's demo does not subscribe
|
||||
// (pinch-only). Wire these up in Codeman (Phase 5) or re-enable in the demo.
|
||||
gc.on("command", ({ name }) => {});
|
||||
|
||||
// Per-frame snapshot for HUD / hover highlighting / debug overlay.
|
||||
// `haltProgress` (0–1 Open_Palm charge) is also still emitted but unused here.
|
||||
gc.on("status", ({ fps, hands, haltProgress }) => {});
|
||||
// hands: { handedness, cursor:{x,y}/*normalized*/, pinchDist, pinching, gesture }[]
|
||||
gc.on("results", ({ result, timestampMs }) => {}); // raw recognizer result
|
||||
|
||||
await gc.start(); // requests camera, loads model
|
||||
await gc.useCamera(deviceId); // switch camera live
|
||||
await gc.listCameras(); // enumerate video inputs
|
||||
gc.stop();
|
||||
```
|
||||
|
||||
All events are live. Hover highlighting is derived from the `status` snapshot
|
||||
(not a dedicated event), since only the consumer can hit-test against its tabs.
|
||||
Full types in [`src/gesture/types.ts`](./src/gesture/types.ts).
|
||||
|
||||
---
|
||||
|
||||
## Tuning defaults (start here, then adjust by feel)
|
||||
|
||||
- **One-Euro filter:** `minCutoff ≈ 1.0`, `beta ≈ 0.01`. Raise `beta` if drag
|
||||
lags during fast moves; lower `minCutoff` if it jitters when still.
|
||||
- **Pinch:** `PINCH_ON 0.35`, `PINCH_OFF 0.5` (fractions of hand-size reference
|
||||
distance, wrist→middle-MCP). Two thresholds = hysteresis = no flicker.
|
||||
- **Confidence:** detection/tracking ≈ 0.6. Lower if quick gestures get missed,
|
||||
raise if you get false hands.
|
||||
- **Camera:** target 30–60fps, even frontal lighting on the hand zone.
|
||||
|
||||
---
|
||||
|
||||
## Design notes
|
||||
|
||||
- **Standalone first.** Fake tabs let us validate feel before touching Codeman.
|
||||
- **Main thread first.** Inference runs on the main thread (60fps, no stutter);
|
||||
a Web Worker stays an optional optimization only if the UI ever stutters.
|
||||
- **Two hands** (`numHands: 2`). Each hand keeps its own cursor + pinch state,
|
||||
keyed by handedness so filters don't swap when MediaPipe reorders the hands.
|
||||
- **Camera angle: front-facing default; superwide now usable too** — iPhone 17
|
||||
Pro main lens via Continuity Camera, pointing / pinch-to-grab grammar. The
|
||||
superwide / Desk View (overhead, ultra-wide) camera now works with no issues
|
||||
and tracking is confirmed on it; the earlier Safari-only / stretched blocker is
|
||||
resolved. The in-app picker switches cameras live.
|
||||
- **Transport-agnostic controller.** It emits coordinate-only `grab`/`drag`/
|
||||
`drop` + `command`; the consumer hit-tests. So Phase 5 only swaps the demo's
|
||||
`tabs.ts` for Codeman wiring — the controller is untouched.
|
||||
@@ -0,0 +1,224 @@
|
||||
# Codeman Gesture Control — Prototype Build Plan
|
||||
|
||||
> Canonical spec for this project. A Jarvis-style hand-tracking input layer for
|
||||
> the Codeman dashboard. Webcam sees your hands; you pinch-drag session tabs
|
||||
> between Screen columns and fire discrete gesture commands. Runs entirely
|
||||
> in-browser, camera feed never leaves the machine.
|
||||
|
||||
Build it as a **standalone prototype first** (its own folder, fake tabs) so the
|
||||
input feel can be validated on real hardware before any integration with
|
||||
Codeman's existing drag/command code.
|
||||
|
||||
---
|
||||
|
||||
## Goal & success criteria
|
||||
|
||||
Build a `GestureController` module + a self-contained demo page that:
|
||||
|
||||
1. Opens the webcam and runs MediaPipe Gesture Recognizer at ~30fps.
|
||||
2. Emits a smoothed cursor position and a `pinch` state (grab/release) from hand landmarks.
|
||||
3. Lets you **drag fake tabs between columns by pinching**, dropping on release.
|
||||
4. Fires **discrete gesture commands** (open palm, thumbs up, victory) onto an event bus.
|
||||
5. Feels responsive — drag lag is not perceptible, jitter is filtered out.
|
||||
|
||||
**Done when:** you can sit at your desk, pinch a tab, move it to another column,
|
||||
release, and it lands — reliably, without visible jitter, with the camera
|
||||
mounted at your chosen angle.
|
||||
|
||||
---
|
||||
|
||||
## Tech stack
|
||||
|
||||
- **MediaPipe Tasks Vision** (`@mediapipe/tasks-vision`) — `GestureRecognizer` in `VIDEO` running mode, `numHands: 1` for v1 (add 2 later). Loads the prebuilt `gesture_recognizer.task` model + WASM from CDN.
|
||||
- **Vanilla TS + Vite** for the prototype (no framework needed; keep it portable so the module drops into Codeman regardless of its stack). If Codeman is React, the module stays framework-agnostic and you wrap it in a hook at integration time.
|
||||
- **One-Euro filter** for cursor smoothing — implement it directly, it's ~40 lines and is the correct tool for noisy interactive landmark streams (low lag at speed, heavy smoothing when still).
|
||||
- **Web Worker** for inference is a **Phase 4** optimization — do NOT start there. Get it working on the main thread first; only move to a worker if the dashboard UI stutters.
|
||||
|
||||
---
|
||||
|
||||
## File structure
|
||||
|
||||
```
|
||||
gesture-proto/
|
||||
├── index.html # demo page: video preview + columns of fake tabs
|
||||
├── package.json
|
||||
├── vite.config.ts
|
||||
├── src/
|
||||
│ ├── main.ts # wires GestureController -> demo UI
|
||||
│ ├── gesture/
|
||||
│ │ ├── GestureController.ts # core: camera + recognizer + state machine + events
|
||||
│ │ ├── OneEuroFilter.ts # cursor smoothing
|
||||
│ │ ├── pinch.ts # pinch detection w/ hysteresis
|
||||
│ │ ├── landmarks.ts # landmark index constants + helpers
|
||||
│ │ └── types.ts # event payload types, config
|
||||
│ └── demo/
|
||||
│ ├── tabs.ts # fake tab/column model + render
|
||||
│ └── overlay.ts # draws hand skeleton + cursor dot over video (debug)
|
||||
└── README.md
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## Core algorithms (the parts that decide whether it feels good)
|
||||
|
||||
### 1. Cursor from landmarks
|
||||
The drag cursor is the **midpoint of thumb tip (landmark 4) and index tip (landmark 8)**, in normalized [0,1] coords from MediaPipe.
|
||||
|
||||
- **Mirror X** (`x = 1 - x`) — the webcam image is flipped relative to the user.
|
||||
- Map normalized → screen pixels against the dashboard's bounding rect.
|
||||
- Run the resulting (x, y) through **two independent One-Euro filters** (one per axis) before using it. Raw landmarks jitter by several pixels even when the hand is still; this is the single most important quality step.
|
||||
|
||||
### 2. Pinch detection with hysteresis
|
||||
Compute euclidean distance between landmark 4 and landmark 8. **Normalize by hand size** (e.g. distance wrist→middle-finger-MCP, landmarks 0→9) so the threshold is robust to how close the hand is to the camera.
|
||||
|
||||
- Use **two thresholds, not one** (hysteresis): enter pinch below `PINCH_ON` (e.g. 0.35 of hand size), exit only above `PINCH_OFF` (e.g. 0.5). This stops flickering between grab/release at the boundary — critical for not "dropping" a tab mid-drag.
|
||||
- Require the pinch state to persist N frames (e.g. 2–3) before firing, to reject single-frame noise.
|
||||
|
||||
### 3. State machine
|
||||
```
|
||||
IDLE ──hand detected──> HOVER ──pinch on──> GRABBED ──pinch off──> (drop) ──> HOVER
|
||||
^ | |
|
||||
└────hand lost───────────┴────────────────hand lost────────────────────────┘
|
||||
```
|
||||
- `HOVER`: cursor moves, highlights the tab/column under it (hit-test).
|
||||
- `GRABBED`: the grabbed tab follows the cursor; emit `drag` events.
|
||||
- On `pinch off` in GRABBED: hit-test cursor against drop columns, emit `drop {tabId, targetColumnId}` or `dropCancelled` if outside any column.
|
||||
|
||||
### 4. Discrete gestures → command bus
|
||||
From `result.gestures[0].categoryName`, debounced (fire once per gesture entry, not every frame while held):
|
||||
- `Open_Palm` held ~1s → `command: "halt-all"` (dead-man's-switch — pauses every session; genuinely useful for autonomous loops).
|
||||
- `Thumb_Up` → `command: "approve"`.
|
||||
- `Victory` → `command: "new-session"`.
|
||||
- Map these to the SAME command names your voice layer already dispatches, so both input sources converge on one dispatcher.
|
||||
|
||||
---
|
||||
|
||||
## GestureController public API (target shape)
|
||||
|
||||
```ts
|
||||
const gc = new GestureController({
|
||||
video: videoEl,
|
||||
surface: dashboardEl, // coords mapped against this element's rect
|
||||
numHands: 1,
|
||||
pinchOn: 0.35, pinchOff: 0.5,
|
||||
palmHoldMs: 1000,
|
||||
});
|
||||
|
||||
gc.on("hover", ({ x, y, targetId }) => {...});
|
||||
gc.on("grab", ({ x, y }) => {...});
|
||||
gc.on("drag", ({ x, y }) => {...}); // throttled to frame rate
|
||||
gc.on("drop", ({ targetColumnId }) => {...});
|
||||
gc.on("command",({ name }) => {...}); // halt-all | approve | new-session
|
||||
gc.on("status", ({ fps, handPresent, pinchDist }) => {...}); // debug HUD
|
||||
|
||||
await gc.start(); // requests camera, loads model
|
||||
gc.stop();
|
||||
```
|
||||
|
||||
Keep it **transport-agnostic**: it emits semantic events, it does NOT know about
|
||||
Codeman's DOM. Integration is just subscribing to these events and calling
|
||||
Codeman's existing tab-move / command functions.
|
||||
|
||||
---
|
||||
|
||||
## Phased build (each phase is independently testable — stop and feel it before moving on)
|
||||
|
||||
**Phase 0 — Scaffold & camera (½ day)**
|
||||
Vite + TS project. `index.html` with a mirrored `<video>` and a "start" button (camera must be a user gesture). Confirm `getUserMedia` works and you see yourself. Must be served over http(s), not `file://`.
|
||||
|
||||
**Phase 1 — Recognizer + debug overlay (½ day)**
|
||||
Load `GestureRecognizer` (`VIDEO` mode, CDN model+wasm). Run `recognizeForVideo(video, performance.now())` in a `requestAnimationFrame` loop. Draw the 21-point skeleton + an FPS counter on a canvas over the video. **Checkpoint: confirm you're getting ≥25fps on your actual camera/lighting setup.** Tune lighting here.
|
||||
|
||||
**Phase 2 — Cursor + pinch (1 day)**
|
||||
Implement `OneEuroFilter` and `pinch.ts`. Render a cursor dot driven by the filtered thumb/index midpoint. Show live pinch distance in the HUD and a color change on grab. **Checkpoint: the dot is steady when your hand is still, and pinch grab/release is crisp with no flicker.** Tune filter constants (`minCutoff`, `beta`) and pinch thresholds here — this is where the "feel" is won or lost.
|
||||
|
||||
**Phase 3 — Drag the fake tabs (1 day)**
|
||||
Build `tabs.ts`: 3 columns of draggable fake "sessions." Wire the state machine: hover-highlight, grab, drag-follow, drop-with-hit-test. **Checkpoint: you can move a tab across columns reliably 10/10 times.** This is the core demo and the real go/no-go for the whole idea.
|
||||
|
||||
**Phase 4 — Discrete commands + polish (1 day)**
|
||||
Add gesture→command bus with debouncing and the 1s open-palm halt. Add an on-screen toast when a command fires. Optional: move inference to a Web Worker if the UI stutters; add second-hand support.
|
||||
|
||||
**Phase 5 — Codeman integration (✅ working, 2026-06-07)**
|
||||
Drop `gesture/` into Codeman via a new consumer `src/codeman/entry.ts` (the core is unchanged; the demo's `main.ts` is *not* the integration point). It binds `grab`/`drag`/`drop` to real `.session-tab`s (grab-to-detach → `app.detachSession`) and pinch-taps the Run / Run Shell toolbar buttons. Runs in Codeman behind `CODEMAN_GESTURE=1`. See the detailed status under "Implementation status" below.
|
||||
|
||||
> **Prerequisite (decided 2026-06-06, ✅ done 2026-06-07): Codeman tab-detach first.**
|
||||
> Codeman needed a **tab-detach / undock** feature — a session pops out into its
|
||||
> own browser window — *before* gesture wiring, because gestures can only drag DOM
|
||||
> *within* the one page that owns the camera (you can't drag a node across isolated
|
||||
> tabs/OS windows). So undock is a Codeman session-placement op the gesture `drop`
|
||||
> *triggers*. **Shipped** as `app.detachSession(id)` → `/session/:id` solo window +
|
||||
> BroadcastChannel sync + re-dock on close (the gesture layer calls it directly).
|
||||
> Per-monitor placement via `getScreenDetails` stays in the multi-monitor backlog.
|
||||
|
||||
---
|
||||
|
||||
## Tuning defaults to start from (then adjust by feel)
|
||||
- One-Euro: `minCutoff ≈ 1.0`, `beta ≈ 0.01` (raise `beta` if drag lags during fast moves; lower `minCutoff` if it's jittery when still).
|
||||
- Pinch: `PINCH_ON 0.35`, `PINCH_OFF 0.5` (fractions of hand-size reference distance).
|
||||
- `min_detection_confidence` / `min_tracking_confidence` ≈ 0.6; lower if quick gestures get missed, raise if you get false hands.
|
||||
- Camera: target 30–60fps, even frontal lighting on the hand zone (matters more than the sensor).
|
||||
|
||||
---
|
||||
|
||||
## Hardware note
|
||||
|
||||
Prototype on the **MacBook M1 Max built-in cam** for zero-friction Phase 0–3.
|
||||
For the real setup, switch to **iPhone via Continuity Camera** mounted at desk
|
||||
level aimed at your hand-gesture zone — best sensor + best angle. Decide
|
||||
front-facing (pointing/pinch-to-grab) vs overhead (swipe/drag-on-a-plane) mount
|
||||
before Phase 3, since it slightly changes the gesture grammar.
|
||||
|
||||
---
|
||||
|
||||
## Implementation status (kept current)
|
||||
|
||||
- ✅ Phase 0, ✅ Phase 1 — see top-level `CLAUDE.md` and `gesture-proto/README.md`.
|
||||
- ✅ Phase 1 fps checkpoint — 60fps on MacBook + iPhone 17 Pro (Continuity Camera).
|
||||
- ✅ Phase 2 — `OneEuroFilter.ts` + `pinch.ts`: filtered cursor dot + pinch hysteresis. Cursor + `pinchDist` + `pinching` on the `status` event; HUD shows pinch distance, cursor ring turns green on grab.
|
||||
- ✅ Phase 3 — `demo/tabs.ts`: 3 Screen columns of draggable session tabs. Controller owns the per-hand pinch state machine and emits `grab`/`drag`/`drop` in surface pixels (with a `hand` id); the demo hit-tests and moves tabs. Two-handed (drag two tabs at once); drop-on-vanish releases a tab if a pinched hand leaves frame.
|
||||
- ✅ Beyond plan — two-hand tracking (`numHands: 2`, filters keyed by handedness) and a live camera picker.
|
||||
- ✅ Camera (2026-06-06) — front-facing iPhone 17 Pro main lens (Chrome) is the default. **The superwide / Desk View (ultra-wide, overhead) camera now works with no issues and tracking is confirmed on it** — the earlier "Safari-only / stretched / unusable" finding is superseded. Pick either via the in-app camera picker.
|
||||
- ✅ Phase 4 (built) — `commands.ts`: debounced gesture→command bus. `Thumb_Up`→approve, `Victory`→new-session (edge-triggered, fire once per entry), `Open_Palm` held `palmHoldMs`→halt-all (dead-man's-switch) with a 0–1 `haltProgress` charge surfaced on `status`. Commands ignore a pinching (mid-drag) hand.
|
||||
- ⛔ **Phase 4 unwired in the demo (2026-06-06).** User wants pinch-drag only — an open palm while reaching to pinch kept charging the hold-to-halt. `main.ts` no longer subscribes to `command`/`haltProgress` and the command/charge toasts are gone. The `GestureController` core is untouched and still emits both events, so Phase 5 (or a re-enabled demo) can pick them up unchanged.
|
||||
- 🐛 **Drag-position fix (2026-06-06).** A `.dragging` tab is `position: absolute`; the `.column`s establish a containing block via `backdrop-filter`, so board-local left/top were offset by the column's own position — tabs in the middle/right columns flew to the right on grab. Fix: `tabs.ts` reparents the floating tab onto `#board` (no filter/transform) for the drag, so the coordinates `moveTo` computes match the containing block.
|
||||
- ✅ **Phase 5 — WORKING at the desk (2026-06-07).** Prerequisite cleared: Codeman tab-detach/undock works in the runtime (`app.detachSession(id)` is the idempotent hook). The gesture overlay runs live in the real Codeman dashboard on `:5000` and was confirmed by the user (normal tab): fullscreen cam + hand/cursor tracking, undock-by-pinch, and Run/Run Shell taps.
|
||||
- **Integration shape: in-page overlay, built into Codeman beta.** The gesture `core` (`src/gesture/`) ships **unchanged**; the consumer is `src/codeman/entry.ts`, esbuild-bundled (`npm run build:codeman`) and served by Codeman at `/gesture/gesture-codeman.js`. A full-viewport, click-through overlay maps coords straight to `elementFromPoint`.
|
||||
- **Gestures (routed by what the pinch lands on):** (a) **grab → in-page floating panel** *(⚠️ pivoted 2026-06-08 — was grab-to-detach)*: pinch a `.session-tab`, a ghost clone follows the hand, pull >`DETACH_PULL_PX` (70) and release → `floatSession(id, x, y)` spawns a re-grabbable `.cg-float` iframe of `/session/:id` (640×420). This **replaced** `window.app.detachSession(id)` (an OS window is a sealed box the hand can't move again — a one-way trip); the float stays in-page so the hand keeps control. See `../../docs/MULTIMONITOR_DESIGN.md`. (b) **Run / Run Shell taps** — pinch over `#runBtn`→`app.run()` / `.btn-shell`→`app.runShell()` and release in place; drift >`TAP_CANCEL_PX` (45) cancels. `CLICK_SELECTOR` is the extensible list. (c) **Fullscreen dimmed cam** by default, **⛶** toggles corner PiP.
|
||||
- **Self-hosted MediaPipe (no CDN).** `entry.ts` passes `wasmBase: "/gesture/wasm"` + `modelUrl: "/gesture/gesture_recognizer.task"`; Codeman serves them same-origin. The CDN path failed in the normal browser tab (content/ad blocker blocking `jsdelivr`/`googleapis`) → surfaced as `failed: {"isTrusted":true}` once `entry.ts` learned to report non-Error throws. Core also gained a GPU→CPU delegate fallback.
|
||||
- **Gated by `CODEMAN_GESTURE=1` (OFF by default).** Under the flag Codeman injects the module script (dashboard only, not `/session/:id` solo popups), cache-busts it with `?v=<mtime>` (static is `max-age=1y`), and widens CSP (`'wasm-unsafe-eval'` + `worker-src 'self' blob:`; same-origin assets now covered by `'self'`). Flag off ⇒ Codeman HTML/CSP unchanged.
|
||||
- **Codeman-side / version control:** the detach + instance isolation + base gesture overlay are committed on `Ark0N/Codeman` branch `beta/session-detach`, open as **PR #103** (tip `afea6d6`; `ceca853` after I fixed its `auth.ts` format:check → CI green). Gotcha: the local prod clone `~/.codeman/app` tracks only `master`, so the branch is hidden until `git fetch origin beta/session-detach` (this briefly misled me into a bogus local reconstruction `03b31b8`, since deleted). The session improvements — direct-detach via `window.app.detachSession`, Run/Run Shell pinch-taps, self-hosted MediaPipe (`/gesture/wasm` + `.task`), and the `server.ts` mtime cache-bust — were **ported onto PR #103** in commit `eea84db` (CI green); their source is `Ark0N/codeman-gesture-control` (`src/codeman/entry.ts`).
|
||||
- **Commits (gesture-proto):** `ddf9cda` (consumer: detach/cam/errors) → `2dd97da` (detach direct) → `21ef793` (Run/Run Shell taps) → `e055b79` (self-host MediaPipe).
|
||||
- **Next:** tune feel; optional in-strip reorder (deferred — user chose detach-only) and more buttons (Stop). Discrete `command` events remain available but unwired (pinch-only). Hand-off brief: `../docs/CODEMAN_DETACH_BRIEF.md`.
|
||||
|
||||
## Backlog (requested, for later)
|
||||
|
||||
- ✅ **Fullscreen mode** — done. Toggle button fullscreens the `#stage`;
|
||||
`:fullscreen` CSS fills the viewport and the coord mapping adapts since it
|
||||
reads the stage rect every frame.
|
||||
- ✅ **Multi-monitor mode — A+C BUILT & validated at the desk (2026-06-08).** The
|
||||
eventual real goal (fling a Codeman session onto an external display by gesture)
|
||||
is reached. **Design → [`../../docs/MULTIMONITOR_DESIGN.md`](../../docs/MULTIMONITOR_DESIGN.md)**,
|
||||
approach **A+C**:
|
||||
- **A — in-page floating panels** (`581fcf9`, `3e0447a`): `entry.ts`
|
||||
`floatSession(id, x, y)` pops a tab into a re-grabbable `.cg-float` iframe of
|
||||
`/session/:id` (640×420) instead of `window.app.detachSession`. The session
|
||||
stays in the camera-owning page's DOM, so the hand keeps control — fixing the
|
||||
one-way-trip flaw of OS-window detach.
|
||||
- **C-span — spanned window** (`063fd8f`, `59946b8`): `scripts/span-codeman.sh`
|
||||
launches a Brave-first (`BROWSER=` override) `--app` window sized to the
|
||||
display union; prereq macOS "Displays have separate Spaces" OFF + re-login.
|
||||
One-click via the **Codeman header button** → `POST /api/system/span-displays`
|
||||
(PR #103 `95b0035`). **Validated:** one window spans both monitors and a panel
|
||||
drags across the seam.
|
||||
- **C-snap** (`getScreenDetails` snapping + seam dead-band) and the **re-dock**
|
||||
gesture/zone are **still pending** — not needed for basic cross-seam dragging.
|
||||
- **Concurrent-rendering question** was RESOLVED first: Codeman already mounts
|
||||
live terminals into floating panels (teammate terminals, log-viewer SSE
|
||||
windows, the iframe-able `/session/:id` solo route), so the live float needed
|
||||
no new Codeman rendering.
|
||||
|
||||
Note: the public event surface evolved from the original API sketch. The
|
||||
controller stays transport-agnostic but emits coordinate-only `grab`/`drag`/
|
||||
`drop` (hit-testing lives in the consumer, since only it knows the DOM/columns).
|
||||
`hover`/`dropCancelled`/`targetId` were dropped; hover highlighting is derived
|
||||
from the `status` snapshot instead.
|
||||
@@ -0,0 +1,80 @@
|
||||
# Feature brief: Session tab detach / undock (for Codeman)
|
||||
|
||||
> ✅ **SHIPPED — on GitHub as PR #103 (open).** Branch `beta/session-detach` on
|
||||
> `Ark0N/Codeman` (base `master`): "feat(web): session detach/undock + beta
|
||||
> instance isolation (port 5000)", containing detach/undock + instance isolation
|
||||
> + the base gesture overlay (commit `afea6d6`). `app.detachSession(id)` in
|
||||
> `app.js` opens `/session/:id` as a solo window (another live client of the same
|
||||
> session), tracks it (badge + `BroadcastChannel` sync + re-dock on close), and is
|
||||
> the single idempotent entry point both the on-tab ⧉ icon and the gesture layer
|
||||
> call. PTY fan-out (the open question below) resolved **yes**, so no streaming
|
||||
> work was needed. CI green after I fixed a prettier format:check on `auth.ts`
|
||||
> (commit `ceca853`).
|
||||
>
|
||||
> ⚠️ **Note:** the local **prod** clone `~/.codeman/app` only tracks `master`, so
|
||||
> the PR branch is invisible there until `git fetch origin beta/session-detach`.
|
||||
> (Earlier today I briefly mis-concluded the PR didn't exist and made a bogus
|
||||
> local reconstruction — deleted. The PR was real all along.) The gesture-side
|
||||
> *improvements* from this session — direct-detach, Run/Run Shell pinch-taps,
|
||||
> self-hosted MediaPipe, `server.ts` cache-bust — were **ported onto PR #103**
|
||||
> (commit `eea84db`, CI green); their source is `Ark0N/codeman-gesture-control`.
|
||||
> The rest of this doc is the original hand-off brief, kept for history.
|
||||
|
||||
> Hand-off brief for **Codeman** to refine and implement **on a beta branch**.
|
||||
> Authored from the gesture-control project, which needs this as a prerequisite.
|
||||
> Codeman is "aicodeman": a Fastify + WebSocket server streaming xterm.js
|
||||
> terminal (tmux) sessions to a web dashboard.
|
||||
|
||||
## Goal
|
||||
|
||||
Let a session "tab" pop out of the main dashboard into its **own browser
|
||||
window** (and back). Each detached window shows just that one session's
|
||||
terminal, fully live. This is a standalone UX win *and* a prerequisite for
|
||||
gesture control later (a hand-gesture "drop" will eventually trigger
|
||||
detach/relocate — but that's a separate project; **this feature is plain UI
|
||||
buttons only**).
|
||||
|
||||
## Core approach (refine as needed)
|
||||
|
||||
- Add a **"Detach" control** on each tab. It opens a new browser window
|
||||
(`window.open`) pointing at a **single-session view** — ideally a real route
|
||||
like `/session/:id` so the popup just loads a URL and attaches like a normal
|
||||
client.
|
||||
- The detached window runs its **own xterm.js instance connected to the same
|
||||
session's WebSocket**, so it's live, not a screenshot.
|
||||
- Keep the dashboard and detached windows **in sync** (session list, titles,
|
||||
alive/dead state, focus) — via the existing events channel, or a
|
||||
`BroadcastChannel` if simpler.
|
||||
- Support **re-dock** (close popup → tab returns to the dashboard) and handle the
|
||||
popup being closed/refreshed gracefully.
|
||||
|
||||
## The one critical question to resolve first (in Codeman's own code)
|
||||
|
||||
Can the server currently **fan out one session's PTY/tmux output to multiple
|
||||
concurrent WebSocket clients**, or is it single-consumer? A detached window is a
|
||||
*second* viewer of the same session. If it's single-consumer today, that's the
|
||||
main change: make the pty→socket stream **broadcast to N subscribers** (and merge
|
||||
input) so dashboard + popup can both watch/type. This likely matters more than
|
||||
the UI work.
|
||||
|
||||
## Other decisions for Codeman
|
||||
|
||||
- Per-session route (`/session/:id`) vs. a single-page popup that's told which id
|
||||
to show.
|
||||
- Multi-monitor placement later via the Window Management API
|
||||
(`getScreenDetails`) — **out of scope now**, just don't design against it.
|
||||
- Auth/cookie sharing so a popup window authenticates the same as the dashboard.
|
||||
|
||||
## Constraints
|
||||
|
||||
- Implement on a **beta branch**, not `main`.
|
||||
- The gesture-control side keeps a **read-only** copy of Codeman (its `.git`
|
||||
removed); the live `Ark0N/Codeman` repo is **not** touched from here. Codeman
|
||||
implements this itself.
|
||||
|
||||
## Why this is sequenced before gesture wiring
|
||||
|
||||
Gestures can only drag DOM **within the single page that owns the camera**; you
|
||||
cannot drag a node across isolated browser tabs / OS windows. So undock must be a
|
||||
**Codeman session-placement operation** that a gesture `drop` later *triggers* —
|
||||
not something the gesture layer does. Detach first; wire gestures to it after.
|
||||
@@ -0,0 +1,260 @@
|
||||
# Multi-monitor gesture design — in-page panels + spanned window (A + C)
|
||||
|
||||
**Status:** **A + C-span BUILT & validated at the desk (2026-06-08).** C-snap
|
||||
(`getScreenDetails` snapping) still pending. Decided + built 2026-06-08.
|
||||
**Supersedes** the OS-window detach as the *gesture* verb (see "Why detach
|
||||
broke movability") — *now actually replaced in `entry.ts`, not just planned.*
|
||||
**Companion docs:** `CODEMAN_DETACH_BRIEF.md` (the original window.open detach),
|
||||
`../gesture-proto/docs/BUILD_PLAN.md` (canonical build spec, Phase 5).
|
||||
|
||||
> ## Implementation status (2026-06-08)
|
||||
> - ✅ **A — in-page floating panels.** `entry.ts` `floatSession(id, x, y)` spawns
|
||||
> a `.cg-float` div with an `<iframe src="/session/:id">` (640×420) at the drop
|
||||
> point; panels are re-grabbable. Replaces `window.app.detachSession`. Commits
|
||||
> `581fcf9`, `3e0447a`.
|
||||
> - ✅ **C-span — spanned window.** `scripts/span-codeman.sh` (Brave-first;
|
||||
> `BROWSER=` override) launches a `--app` window sized to the display union.
|
||||
> Commits `063fd8f`, `59946b8`. **Validated at the desk:** one window spans
|
||||
> both monitors (3432×1080) and a panel drags across the seam.
|
||||
> - ✅ **Launch entry point in Codeman.** A header "multi-monitor" button (replaces
|
||||
> the notification bell) → `POST /api/system/span-displays` → spawns the span
|
||||
> script. Bundled `span-codeman.sh` into Codeman's repo. **PR #103** `95b0035`.
|
||||
> - ✅ **Cache-bust** all same-origin module scripts/CSS (`renderIndexHtml` →
|
||||
> `cacheBustAssets`), so frontend edits show on a normal reload. PR #103 `b5ea711`.
|
||||
> - ⏳ **C-snap** (`getScreenDetails` snapping + seam dead-band) — not built; not
|
||||
> required for basic cross-seam dragging. Also pending: the re-dock gesture/zone.
|
||||
> - **Known caveats from the desk run:** dead band on a taller/offset external
|
||||
> display (inherent to one spanning rect); superwide lens not selectable in the
|
||||
> fresh span-window browser profile; 3-monitor works unchanged but dead-space +
|
||||
> cursor-sensitivity caveats grow.
|
||||
|
||||
---
|
||||
|
||||
## Goal
|
||||
|
||||
Pinch a Codeman session, drag it anywhere — including **across a second
|
||||
physical monitor** — drop it, and have it stay where you put it and stay
|
||||
grabbable again. The "fling a session onto the external display by gesture"
|
||||
end-goal from the BUILD_PLAN backlog, made real **without losing the ability to
|
||||
move a session after you've placed it.**
|
||||
|
||||
## The root constraint (why this design, not the others)
|
||||
|
||||
The hand only exists in **the one page that owns the camera**. Hand tracking,
|
||||
the cursor, and `document.elementFromPoint` hit-testing all live in that single
|
||||
document. **An OS window created by `window.open` is a sealed box that page
|
||||
cannot reach into** — no shared DOM, no shared cursor.
|
||||
|
||||
> **Why detach broke movability.** Today `entry.ts` → `detach(id)` calls
|
||||
> `window.app.detachSession(id)`, which `window.open`s the session into its own
|
||||
> OS window. The instant it leaves the camera-owning page, the hand can never
|
||||
> touch it again. Detach-by-pinch *works*, but it's a one-way trip.
|
||||
|
||||
**Rule:** anything you want to keep gesture-movable must stay inside **one
|
||||
page's DOM.** This design honors that with two composed pieces:
|
||||
|
||||
- **A — In-page floating panels.** "Detach" pops a session into a free-floating,
|
||||
absolutely-positioned element *in the same page* (not an OS window), so the
|
||||
hand keeps control forever.
|
||||
- **C — One window spanning both monitors.** Run Codeman in a single window
|
||||
stretched across both physical displays, so "drag across monitors" is just
|
||||
"drag across the page," and the second monitor's pixels are actually used.
|
||||
|
||||
Option **B** (one OS window per monitor + a distributed BroadcastChannel cursor
|
||||
protocol + cross-window session hand-off) was considered and deferred: it's the
|
||||
only path to *independent* per-monitor OS windows, but it's a much larger build
|
||||
and reintroduces the cross-window wall this design exists to avoid.
|
||||
|
||||
---
|
||||
|
||||
## Part A — In-page floating panels
|
||||
|
||||
### Codeman already has the primitive
|
||||
|
||||
`panels-ui.js` has a `.detached` "floating window": an absolutely-positioned
|
||||
`<div>` with `panel.style.top/left/width/height` and a drag handler
|
||||
(`setupMonitorDrag`) — **all in-page, no `window.open`.** The session-tab detach
|
||||
simply picked the wrong primitive (the OS-window one). Part A reuses the
|
||||
in-page one.
|
||||
|
||||
### Concurrent session rendering — RESOLVED (2026-06-08): live floats are feasible now
|
||||
|
||||
The main *dashboard view* renders **one active session at a time** (a single
|
||||
shared `this.terminal` opened into `#terminalContainer` in `terminal-ui.js:26`,
|
||||
swapped by `selectSession()`). But the page is **not** limited to one terminal —
|
||||
the PR #103 branch already ships **three independent in-page concurrent
|
||||
floating-content subsystems** we can reuse, so a live floating panel per session
|
||||
needs **no new Codeman rendering architecture**:
|
||||
|
||||
1. **Teammate terminals** (`panels-ui.js` `teammateTerminals` Map +
|
||||
`subagent-windows.js`). A `Map` of **concurrent live `new Terminal()`
|
||||
instances**, each `terminal.open(body)`'d into a floating panel, bound to a
|
||||
`sessionId` + tmux `paneTarget`, **seeded via REST** buffer fetch
|
||||
(`/api/sessions/:id/teammate-pane-buffer/:pane`), **input via REST**
|
||||
(`/api/sessions/:id/teammate-pane-input`), with lazy-mount (`_lazyPaneTarget`)
|
||||
and `dispose()` cleanup. *This is option 2 already built and shipping.*
|
||||
2. **Log-viewer windows** (`panels-ui.js:2632`). Concurrent draggable floating
|
||||
windows, each with its own `EventSource` **SSE stream** and lifecycle map —
|
||||
proof of the generic "floating window + independent per-window stream"
|
||||
pattern.
|
||||
3. **`/session/:id` solo route** (`server.ts:573`, `renderIndexHtml(soloId)`,
|
||||
`text/event-stream` at `:633`). A full **standalone live session page** —
|
||||
**iframe-able** — reusing the exact multi-client fan-out detach already
|
||||
depends on. Solo mode deliberately **omits** the gesture overlay
|
||||
(`server.ts:1010-1014`), so there's no nested-overlay problem.
|
||||
|
||||
**The PTY multi-viewer fan-out is confirmed** (the brief's open "yes"): a session
|
||||
is addressable by multiple concurrent clients — the solo route, the teammate
|
||||
REST endpoints, and the on-tab pop-out all view the same live session.
|
||||
|
||||
**Resolution:** skip the static-preview fallback. Build live floats directly,
|
||||
ranked by new-code cost:
|
||||
|
||||
- **Primary — iframe the solo route.** `floatPanel(id)` =
|
||||
`<div class="cg-float" data-id><iframe src="/session/:id"></iframe></div>`.
|
||||
The iframe is a complete live session view (its own terminal + stream client);
|
||||
the gesture layer moves the **div** and the iframe rides along. Lowest new
|
||||
code; reuses proven fan-out; no terminal wiring. Trade-off: a full app shell
|
||||
per float (heavier — fine for a few, watch memory at many).
|
||||
- **Richer alt — native teammate-style panel.** Mount a `new Terminal()` in the
|
||||
float body, seed via the session buffer endpoint, feed via the teammate
|
||||
stream. Native (no iframe), lighter per-float, same-document. Use if the
|
||||
iframe feels heavy or you want tighter integration.
|
||||
|
||||
Either way the hand only **places** the float; typing into it uses a keyboard
|
||||
(focus the iframe / native terminal) — consistent with "gesture places,
|
||||
keyboard types."
|
||||
|
||||
### Gesture grammar (replaces the current detach path in `entry.ts`)
|
||||
|
||||
The grab/drag/drop plumbing already exists; only the **drop action** changes.
|
||||
|
||||
- **Grab** a `.session-tab[data-id]` (unchanged: `onGrab`, ghost-follow).
|
||||
- **Pull** past `DETACH_PULL_PX` to arm (unchanged: `grab.armed`).
|
||||
- **Drop while armed** → **no longer** `window.app.detachSession`. Instead spawn
|
||||
an **in-page floating panel** for that session id at the drop point. New
|
||||
method `floatPanel(id, x, y)` replacing `detach(id)`.
|
||||
- **Re-grab** a floating panel (new `PANEL_SELECTOR`, e.g. `.cg-float[data-id]`)
|
||||
→ move it; drop anywhere → it stays. This is the capability detach lost.
|
||||
- **Drop a panel back over the tab strip** (or a dock zone) → **re-dock**
|
||||
(remove the float; session returns to a plain tab). Mirrors the `.detached` →
|
||||
attach toggle Codeman already has.
|
||||
- **Keep `window.open` detach as a separate, deliberate verb** — e.g. a button,
|
||||
or a distinct "throw up and off-screen" gesture — for intentionally parking a
|
||||
session in its own OS window. It is *not* the default pinch action anymore.
|
||||
|
||||
### `entry.ts` change surface
|
||||
|
||||
- New state: `floats: Map<string, FloatingPanel>` (id → element + position),
|
||||
parallel to the existing `grabs`/`taps` maps.
|
||||
- `onGrab`: extend hit-testing to also match `PANEL_SELECTOR`, so an existing
|
||||
float can be re-grabbed (priority: panel over tab when overlapping).
|
||||
- `onDrop`: replace `if (grab.armed) this.detach(grab.id)` with
|
||||
`this.floatPanel(...)`; add the panel re-dock branch.
|
||||
- `floatPanel(id, x, y)`: create/show the in-page panel (Part A option 1/2),
|
||||
position it absolutely at the drop point. Idempotent per id (re-grab moves the
|
||||
existing one, never duplicates).
|
||||
- Coordinate mapping is **already viewport-pixel based** (the click-through
|
||||
surface maps cursor → viewport px), so it needs **no change** for spanning —
|
||||
see Part C.
|
||||
|
||||
---
|
||||
|
||||
## Part C — One window spanning both monitors
|
||||
|
||||
Once the Codeman window physically covers both displays, Part A's panels drag
|
||||
across the seam for free, because the gesture cursor is already in viewport
|
||||
pixels and the viewport now spans both monitors.
|
||||
|
||||
### macOS setup (operational, near-zero code)
|
||||
|
||||
1. **System Settings → Desktop & Dock → uncheck "Displays have separate
|
||||
Spaces."** (Requires a logout/login.) This is what lets a single window
|
||||
straddle two physical displays.
|
||||
2. Run Codeman **maximized, not fullscreen.** Browser fullscreen is *per
|
||||
display* and will **not** span — use a maximized/borderless window dragged to
|
||||
cover both monitors. (A kiosk/`--app` Chrome window sized to the union rect is
|
||||
the cleanest.) **Automated by `scripts/span-codeman.sh`** — it reads the
|
||||
display-union rect (Finder desktop bounds) and launches a **Brave-first**
|
||||
Chromium-family `--app` window sized to it (fresh per-browser profile so the
|
||||
geometry flags are honored; `BROWSER=` overrides — plain Chrome bounced on the
|
||||
desk machine). One-click from the **Codeman header "multi-monitor" button**
|
||||
(`POST /api/system/span-displays`, which spawns this script), or run it
|
||||
directly. Step 1 + logout is still manual; the script warns if spanning isn't
|
||||
active.
|
||||
3. Arrange the two monitors as a contiguous rectangle in Display settings so the
|
||||
union has no vertical offset gap.
|
||||
|
||||
### Coordinate model & the bezel seam
|
||||
|
||||
- Enumerate displays with **`window.getScreenDetails()`** (Chrome, secure
|
||||
context, `window-management` permission). Gives each screen's
|
||||
`left/top/width/height/availLeft/...` in a **virtual-desktop coordinate
|
||||
space** spanning all monitors.
|
||||
- Use it for **screen-edge snapping zones**: e.g. dropping a panel within the
|
||||
right screen's bounds snaps it to fill that screen; the seam between the two
|
||||
screens' rects is a "halt / boundary" zone the cursor crosses.
|
||||
- **Account for the bezel gap.** The two monitors are physically separated, but
|
||||
the spanned window's pixels are contiguous — a panel dragged across the seam
|
||||
visually jumps the bezel. Optional: add a dead-band at the seam x-coordinate
|
||||
so a panel snaps to one side rather than straddling.
|
||||
- `getScreenDetails` is **only needed for snapping/zone logic**, not for basic
|
||||
dragging — dragging works the moment the window spans. So Part C can ship in
|
||||
two steps: (1) just span + free drag, (2) add `getScreenDetails` snapping.
|
||||
|
||||
### Constraints to surface to the user
|
||||
|
||||
- macOS-specific; the "separate Spaces" toggle is global and affects all apps.
|
||||
- Real fullscreen is unavailable (must run maximized).
|
||||
- A bezel-width discontinuity sits in the middle of the coordinate space.
|
||||
- `window-management` permission prompts once.
|
||||
|
||||
---
|
||||
|
||||
## Build phases
|
||||
|
||||
1. ✅ **A-MVP — in-page live float, single monitor (DONE, `581fcf9`/`3e0447a`).**
|
||||
`entry.ts` `floatSession(id, x, y)` spawns an **iframe of `/session/:id`** in a
|
||||
`.cg-float` div (640×420) at the drop point; re-grab + move work (re-dock zone
|
||||
still TBD). Movability restored — the live session rides inside the page. (The
|
||||
method is named `floatSession`, not the design-sketch `floatPanel`.)
|
||||
2. ✅ **C-span — span the window (DONE, `063fd8f`/`59946b8`; validated at desk).**
|
||||
macOS "separate Spaces" off + `scripts/span-codeman.sh` launches a maximized
|
||||
`--app` window across the display union (Brave-first; `BROWSER=` override).
|
||||
**Confirmed:** panels drag across the seam — viewport mapping held with zero
|
||||
`entry.ts` change. Launchable one-click from the **Codeman header button** →
|
||||
`POST /api/system/span-displays` (PR #103 `95b0035`), or by running the script.
|
||||
3. ⏳ **C-snap — screen-aware snapping (pending).** Add `getScreenDetails`; snap a
|
||||
panel to the screen it's dropped on; add the seam dead-band.
|
||||
4. **A-alt (optional).** Swap the iframe float for a native teammate-style
|
||||
`new Terminal()` panel if the iframe shell feels heavy or many floats strain
|
||||
memory.
|
||||
|
||||
## Open questions / verification before coding
|
||||
|
||||
- [x] **Concurrent rendering — RESOLVED (2026-06-08).** A live session view
|
||||
*can* be mounted into an arbitrary in-page container concurrently with the
|
||||
main view. The PR #103 branch already ships it three ways (teammate terminals,
|
||||
log-viewer SSE windows, the iframe-able `/session/:id` solo route); fan-out
|
||||
confirmed. Primary path: iframe the solo route. See the resolved section above.
|
||||
- [ ] **Native-panel live feed (only if taking A-alt, not the iframe):** trace
|
||||
the exact transport that pushes *continuous* teammate-pane output after the
|
||||
REST buffer seed (`pendingData` flush source). The iframe path sidesteps this.
|
||||
- [ ] **`window.app.detachSession` location:** when wiring the *kept* OS-window
|
||||
detach verb, note this method was **not found in PR #103 source** (only
|
||||
server-side `detachSessionListeners`); it works at runtime, so confirm where
|
||||
it's actually defined before extending it.
|
||||
- [ ] **Spanning feasibility on the actual desk setup** (monitor arrangement,
|
||||
whether "separate Spaces" off is acceptable to the user globally).
|
||||
- [ ] **Re-dock target:** decide the re-dock gesture/zone (drop over tab strip
|
||||
vs a dedicated dock region).
|
||||
|
||||
## Touch-points summary
|
||||
|
||||
| Layer | File | Change | Status |
|
||||
|-------|------|--------|--------|
|
||||
| Gesture consumer | `gesture-proto/src/codeman/entry.ts` | `detach()` → `floatSession()`; `floats` map; panel re-grab; (later) re-dock branch + `getScreenDetails` snapping | ✅ float+re-grab done (`581fcf9`/`3e0447a`); re-dock/snap pending |
|
||||
| Gesture core | `gesture-proto/src/gesture/*` | **none** — stays transport-agnostic | ✅ unchanged |
|
||||
| Codeman — launch | `src/web/routes/system-routes.ts`, `src/web/public/{index.html,panels-ui.js}`, `scripts/span-codeman.sh` | header button → `POST /api/system/span-displays` → spawn span script (bundled into repo) | ✅ PR #103 `95b0035` |
|
||||
| Codeman — caching | `src/web/server.ts` | `cacheBustAssets()` — `?v=<mtime>` on all same-origin `.js`/`.css` so frontend edits show on normal reload | ✅ PR #103 `b5ea711` |
|
||||
| Ops | macOS display settings + `scripts/span-codeman.sh` | "separate Spaces" off + re-login; Brave-first maximized spanning window | ✅ validated at desk |
|
||||
@@ -0,0 +1,208 @@
|
||||
<!doctype html>
|
||||
<html lang="en">
|
||||
<head>
|
||||
<meta charset="UTF-8" />
|
||||
<meta name="viewport" content="width=device-width, initial-scale=1.0" />
|
||||
<title>Codeman Gesture Control — Phase 4</title>
|
||||
<style>
|
||||
:root {
|
||||
color-scheme: dark;
|
||||
--bg: #0b0f17;
|
||||
--panel: #131a26;
|
||||
--ink: #e6edf3;
|
||||
--muted: #94a3b8;
|
||||
--accent: #38bdf8;
|
||||
}
|
||||
* { box-sizing: border-box; }
|
||||
body {
|
||||
margin: 0;
|
||||
font-family: ui-sans-serif, system-ui, -apple-system, sans-serif;
|
||||
background: var(--bg);
|
||||
color: var(--ink);
|
||||
min-height: 100vh;
|
||||
display: flex;
|
||||
flex-direction: column;
|
||||
align-items: center;
|
||||
gap: 1rem;
|
||||
padding: 1.5rem;
|
||||
}
|
||||
h1 { font-size: 1.25rem; margin: 0; font-weight: 650; }
|
||||
.sub { color: var(--muted); font-size: 0.85rem; margin: 0; }
|
||||
|
||||
.stage {
|
||||
position: relative;
|
||||
width: min(90vw, 960px);
|
||||
aspect-ratio: 16 / 9;
|
||||
background: #000;
|
||||
border-radius: 12px;
|
||||
overflow: hidden;
|
||||
box-shadow: 0 10px 40px rgba(0, 0, 0, 0.5);
|
||||
}
|
||||
/* Fullscreen: fill the display so grab targets get big. Coord mapping
|
||||
reads the stage rect each frame, so it adapts automatically. */
|
||||
#stage:fullscreen,
|
||||
#stage:-webkit-full-screen {
|
||||
width: 100vw;
|
||||
height: 100vh;
|
||||
max-width: none;
|
||||
aspect-ratio: auto;
|
||||
border-radius: 0;
|
||||
}
|
||||
/* Mirror the camera so it reads like a, er, mirror. */
|
||||
#cam {
|
||||
position: absolute;
|
||||
inset: 0;
|
||||
width: 100%;
|
||||
height: 100%;
|
||||
object-fit: cover;
|
||||
transform: scaleX(-1);
|
||||
}
|
||||
/* Overlay is NOT CSS-mirrored; overlay.ts mirrors coords itself.
|
||||
z-index 2 keeps the cursor + skeleton drawn over the tab board. */
|
||||
#overlay {
|
||||
position: absolute;
|
||||
inset: 0;
|
||||
width: 100%;
|
||||
height: 100%;
|
||||
pointer-events: none;
|
||||
z-index: 2;
|
||||
}
|
||||
|
||||
/* Phase 3 tab board — overlays the video; gesture-driven, no mouse. */
|
||||
#board {
|
||||
position: absolute;
|
||||
inset: 0;
|
||||
display: flex;
|
||||
gap: 12px;
|
||||
padding: 12px;
|
||||
pointer-events: none;
|
||||
z-index: 1;
|
||||
}
|
||||
#board .column {
|
||||
flex: 1;
|
||||
min-width: 0;
|
||||
display: flex;
|
||||
flex-direction: column;
|
||||
background: rgba(11, 15, 23, 0.55);
|
||||
border: 1px solid #25324a;
|
||||
border-radius: 10px;
|
||||
backdrop-filter: blur(3px);
|
||||
transition: border-color 0.1s, background 0.1s;
|
||||
}
|
||||
#board .column.col-hot {
|
||||
border-color: var(--accent);
|
||||
background: rgba(56, 189, 248, 0.18);
|
||||
}
|
||||
#board .column > header {
|
||||
font-size: 0.78rem;
|
||||
font-weight: 650;
|
||||
color: var(--muted);
|
||||
padding: 0.5rem 0.6rem;
|
||||
border-bottom: 1px solid #25324a;
|
||||
}
|
||||
#board .tablist {
|
||||
flex: 1;
|
||||
padding: 0.5rem;
|
||||
display: flex;
|
||||
flex-direction: column;
|
||||
gap: 0.4rem;
|
||||
overflow: hidden;
|
||||
}
|
||||
#board .tab {
|
||||
background: #1b2740;
|
||||
border: 1px solid #2c3c5c;
|
||||
border-radius: 8px;
|
||||
padding: 0.85rem 0.7rem;
|
||||
min-height: 3rem;
|
||||
display: flex;
|
||||
align-items: center;
|
||||
font-size: 0.95rem;
|
||||
font-weight: 550;
|
||||
font-variant-numeric: tabular-nums;
|
||||
box-shadow: 0 1px 2px rgba(0, 0, 0, 0.3);
|
||||
transition: border-color 0.1s, transform 0.05s;
|
||||
}
|
||||
#board .tab.tab-hot {
|
||||
border-color: var(--accent);
|
||||
background: #22304d;
|
||||
}
|
||||
#board .tab.dragging {
|
||||
position: absolute;
|
||||
z-index: 5;
|
||||
width: auto;
|
||||
box-shadow: 0 12px 30px rgba(0, 0, 0, 0.55);
|
||||
transform: scale(1.05);
|
||||
opacity: 0.97;
|
||||
border-color: #4ade80;
|
||||
}
|
||||
|
||||
.controls { display: flex; gap: 0.75rem; align-items: center; }
|
||||
button {
|
||||
background: var(--accent);
|
||||
color: #04222e;
|
||||
border: 0;
|
||||
border-radius: 8px;
|
||||
padding: 0.55rem 1.1rem;
|
||||
font-size: 0.95rem;
|
||||
font-weight: 650;
|
||||
cursor: pointer;
|
||||
}
|
||||
button:disabled { opacity: 0.4; cursor: not-allowed; }
|
||||
button.ghost { background: var(--panel); color: var(--ink); }
|
||||
select {
|
||||
background: var(--panel);
|
||||
color: var(--ink);
|
||||
border: 1px solid #25324a;
|
||||
border-radius: 8px;
|
||||
padding: 0.5rem 0.75rem;
|
||||
font-size: 0.9rem;
|
||||
max-width: 16rem;
|
||||
}
|
||||
select:disabled { opacity: 0.4; cursor: not-allowed; }
|
||||
|
||||
.hud {
|
||||
display: flex;
|
||||
gap: 1.5rem;
|
||||
background: var(--panel);
|
||||
border-radius: 10px;
|
||||
padding: 0.75rem 1.25rem;
|
||||
font-variant-numeric: tabular-nums;
|
||||
font-size: 0.9rem;
|
||||
}
|
||||
.hud .label { color: var(--muted); margin-right: 0.4rem; }
|
||||
.hud b { font-weight: 650; }
|
||||
|
||||
#status-msg { color: var(--muted); font-size: 0.85rem; min-height: 1.2em; margin: 0; }
|
||||
</style>
|
||||
</head>
|
||||
<body>
|
||||
<h1>Codeman Gesture Control</h1>
|
||||
<p class="sub">Phase 4 — pinch-drag tabs + discrete gesture commands. Camera feed never leaves this machine.</p>
|
||||
|
||||
<div class="stage" id="stage">
|
||||
<video id="cam" autoplay muted playsinline></video>
|
||||
<div id="board"></div>
|
||||
<canvas id="overlay"></canvas>
|
||||
</div>
|
||||
|
||||
<div class="controls">
|
||||
<button id="start">Start camera</button>
|
||||
<button id="stop" class="ghost" disabled>Stop</button>
|
||||
<button id="fullscreen" class="ghost" title="Toggle fullscreen (Esc to exit)">⛶ Fullscreen</button>
|
||||
<select id="camera" disabled title="Choose camera (populated after start)">
|
||||
<option>Default camera</option>
|
||||
</select>
|
||||
</div>
|
||||
|
||||
<div class="hud">
|
||||
<span><span class="label">FPS</span><b id="fps">0</b></span>
|
||||
<span><span class="label">Hands</span><b id="hand">no</b></span>
|
||||
<span><span class="label">Pinch</span><b id="pinch">—</b></span>
|
||||
<span><span class="label">Gesture</span><b id="gesture">—</b></span>
|
||||
</div>
|
||||
|
||||
<p id="status-msg">Click “Start camera” to begin (camera access requires a click).</p>
|
||||
|
||||
<script type="module" src="/src/main.ts"></script>
|
||||
</body>
|
||||
</html>
|
||||
@@ -0,0 +1,28 @@
|
||||
{
|
||||
"name": "codeman-gesture-control",
|
||||
"private": true,
|
||||
"version": "0.1.0",
|
||||
"type": "module",
|
||||
"description": "Jarvis-style hand-tracking input layer for the Codeman dashboard. Vendored into the Codeman repo; the Codeman bundle (src/codeman/entry.ts) is built into src/web/public/gesture/gesture-codeman.js by `npm run build:gesture` at the repo root.",
|
||||
"scripts": {
|
||||
"dev": "vite",
|
||||
"preview": "vite preview",
|
||||
"typecheck": "tsc --noEmit",
|
||||
"build:demo": "tsc && vite build",
|
||||
"build:codeman": "esbuild src/codeman/entry.ts --bundle --format=esm --target=es2020 --outfile=dist-codeman/gesture-codeman.js"
|
||||
},
|
||||
"dependencies": {
|
||||
"@mediapipe/tasks-vision": "0.10.21"
|
||||
},
|
||||
"devDependencies": {
|
||||
"esbuild": "^0.27.3",
|
||||
"typescript": "^5.5.4",
|
||||
"vite": "^7.3.5"
|
||||
},
|
||||
"homepage": "https://github.com/Ark0N/Codeman/tree/master/packages/gesture-control#readme",
|
||||
"repository": {
|
||||
"type": "git",
|
||||
"url": "git+https://github.com/Ark0N/Codeman.git",
|
||||
"directory": "packages/gesture-control"
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,518 @@
|
||||
// Phase 5 — Codeman integration entry point.
|
||||
//
|
||||
// This is the *consumer* layer that replaces `demo/tabs.ts` for the real
|
||||
// Codeman dashboard. It is bundled (esbuild, MediaPipe included) into a single
|
||||
// ESM file and served by Codeman from `/gesture/gesture-codeman.js`, loaded into
|
||||
// the dashboard page when Codeman is started with `CODEMAN_GESTURE=1`.
|
||||
//
|
||||
// The gesture *core* (`../gesture/*`) is unchanged and transport-agnostic — it
|
||||
// emits coordinate-only `grab`/`drag`/`drop`. Here we map those onto Codeman's
|
||||
// real session tabs (`.session-tab[data-id]`) and toolbar buttons.
|
||||
//
|
||||
// Three interactions, all off the same pinch:
|
||||
// • Tab "grab-to-float" — pinch a session tab, *pull it out* of the strip (a
|
||||
// ghost follows your hand), release past a threshold → the session opens as
|
||||
// an in-page floating panel at the drop point; a small twitch-and-release
|
||||
// cancels (snaps back).
|
||||
// • Panel "re-grab" — pinch an existing floating panel and move it anywhere;
|
||||
// release over the tab strip to re-dock it (panel goes away, the tab stays).
|
||||
// This is the capability the old OS-window detach lost.
|
||||
// • Button "tap" — pinch over a toolbar button (Run / Run Shell) and release
|
||||
// in place → fires the button's real click handler. Drift too far first and
|
||||
// it's treated as a stray move, not a tap.
|
||||
//
|
||||
// Why in-page floats, not OS-window detach (decided 2026-06-08, see
|
||||
// docs/MULTIMONITOR_DESIGN.md): the hand only exists in the one page that owns
|
||||
// the camera. `window.open`/`detachSession` puts the session in a sealed OS
|
||||
// window the page can't hand-track — a detached session can never be moved
|
||||
// again, a one-way trip. A floating panel (an iframe of the session's solo
|
||||
// route `/session/:id`) stays in this page's DOM, so the hand keeps control:
|
||||
// re-grab, move across the (spanned) viewport, drop, re-dock. The OS-window
|
||||
// detach is kept for later as a *separate, deliberate* verb — no longer the pinch.
|
||||
|
||||
import { GestureController } from '../gesture/GestureController.ts';
|
||||
import type { HandState } from '../gesture/types.ts';
|
||||
|
||||
declare global {
|
||||
interface Window {
|
||||
__codemanGesture?: GestureBridge;
|
||||
}
|
||||
}
|
||||
|
||||
const TAB_SELECTOR = '.session-tab';
|
||||
/** An in-page floating session panel this layer spawned — re-grabbable to move. */
|
||||
const PANEL_SELECTOR = '.cg-float';
|
||||
/** The session-tab strip; dropping a moved panel over it re-docks the session. */
|
||||
const DOCK_SELECTOR = '.session-tabs';
|
||||
/** Toolbar buttons a pinch can "tap": Run (#runBtn → app.run()) and Run Shell
|
||||
* (.btn-shell → app.runShell()). Pinch over one and release in place to fire
|
||||
* it. Extend this list to expose more buttons to the gesture layer. */
|
||||
const CLICK_SELECTOR = '#runBtn, .btn-shell';
|
||||
const Z = 2147483000; // above the dashboard, below nothing that matters at the desk
|
||||
/** Floating-panel size (px). Fixed for the MVP; resize is a later affordance. */
|
||||
const FLOAT_W = 640;
|
||||
const FLOAT_H = 420;
|
||||
/** Minimum pull distance (px) from the grab point before a release floats the
|
||||
* tab out. Below this it's an accidental pinch and the tab snaps back. */
|
||||
const DETACH_PULL_PX = 70;
|
||||
/** If a button-pinch drifts more than this, it's a stray move, not a tap. */
|
||||
const TAP_CANCEL_PX = 45;
|
||||
|
||||
/** First letter colours: cyan left, violet right; green while pinching. */
|
||||
const handColor = (handedness: string, pinching: boolean): string =>
|
||||
pinching ? '#4ade80' : handedness === 'Right' ? '#a78bfa' : '#38bdf8';
|
||||
|
||||
/** A floating in-page session panel (an iframe of `/session/:id`) the hand can
|
||||
* place and re-grab. Stays in this page's DOM, so it never leaves hand reach. */
|
||||
interface FloatingPanel {
|
||||
id: string;
|
||||
/** The `.cg-float` container element. */
|
||||
el: HTMLElement;
|
||||
}
|
||||
|
||||
/** Live state for one hand's in-progress grab — either a session *tab* being
|
||||
* pulled out into a new float, or an existing *panel* being moved/re-docked. */
|
||||
type Grab =
|
||||
| {
|
||||
kind: 'tab';
|
||||
id: string;
|
||||
tab: HTMLElement;
|
||||
ghost: HTMLElement;
|
||||
/** Grab origin in viewport px, to measure pull distance. */
|
||||
ox: number;
|
||||
oy: number;
|
||||
/** Pulled past the float-out threshold at least once. */
|
||||
armed: boolean;
|
||||
}
|
||||
| {
|
||||
kind: 'panel';
|
||||
id: string;
|
||||
panel: FloatingPanel;
|
||||
/** Cursor→panel-top-left offset at grab, so it doesn't snap when re-grabbed. */
|
||||
dx: number;
|
||||
dy: number;
|
||||
/** Cursor currently over the tab strip → releasing re-docks. */
|
||||
overDock: boolean;
|
||||
};
|
||||
|
||||
/** Live state for one hand pinching a toolbar button (Run / Run Shell). */
|
||||
interface Tap {
|
||||
el: HTMLElement;
|
||||
label: string;
|
||||
ox: number;
|
||||
oy: number;
|
||||
}
|
||||
|
||||
class GestureBridge {
|
||||
private readonly surface: HTMLDivElement;
|
||||
private readonly canvas: HTMLCanvasElement;
|
||||
private readonly ctx: CanvasRenderingContext2D;
|
||||
private readonly video: HTMLVideoElement;
|
||||
private readonly button: HTMLButtonElement;
|
||||
private readonly camBtn: HTMLButtonElement;
|
||||
private readonly status: HTMLSpanElement;
|
||||
private readonly gc: GestureController;
|
||||
private running = false;
|
||||
/** Camera view: full-viewport dimmed background, or small corner preview. */
|
||||
private camMode: 'full' | 'pip' = 'full';
|
||||
|
||||
/** Per-hand in-progress grab (a tab being pulled out, or a panel being moved). */
|
||||
private grabs = new Map<string, Grab>();
|
||||
/** Per-hand in-progress button pinch (fires on release if it didn't drift). */
|
||||
private taps = new Map<string, Tap>();
|
||||
/** Live floating panels, keyed by session id (idempotent per id). */
|
||||
private floats = new Map<string, FloatingPanel>();
|
||||
|
||||
constructor() {
|
||||
injectStyles();
|
||||
|
||||
// Full-viewport, click-through surface so coords map straight to viewport
|
||||
// pixels and elementFromPoint() sees the tabs beneath, not our overlay.
|
||||
this.surface = el('div', 'cg-surface') as HTMLDivElement;
|
||||
this.canvas = el('canvas', 'cg-canvas') as HTMLCanvasElement;
|
||||
this.video = el('video', 'cg-preview') as HTMLVideoElement;
|
||||
this.video.muted = true;
|
||||
this.video.playsInline = true;
|
||||
this.applyCamMode();
|
||||
|
||||
const dock = el('div', 'cg-dock');
|
||||
this.button = el('button', 'cg-btn') as HTMLButtonElement;
|
||||
this.button.textContent = '🖐 Gesture';
|
||||
this.camBtn = el('button', 'cg-btn cg-btn-icon') as HTMLButtonElement;
|
||||
this.camBtn.textContent = '⛶';
|
||||
this.camBtn.title = 'Toggle camera size (fullscreen / corner)';
|
||||
this.status = el('span', 'cg-status') as HTMLSpanElement;
|
||||
this.status.textContent = 'off';
|
||||
dock.append(this.button, this.camBtn, this.status);
|
||||
|
||||
document.body.append(this.surface, this.video, this.canvas, dock);
|
||||
this.ctx = this.canvas.getContext('2d')!;
|
||||
this.sizeCanvas();
|
||||
window.addEventListener('resize', () => this.sizeCanvas());
|
||||
|
||||
this.gc = new GestureController({
|
||||
video: this.video,
|
||||
surface: this.surface,
|
||||
numHands: 1,
|
||||
// Self-host the MediaPipe runtime + model from Codeman (same-origin) instead
|
||||
// of the CDN, so an ad/content blocker, offline desk, or strict browser
|
||||
// can't break startup (the CDN failure surfaced as `failed: {isTrusted}` —
|
||||
// a resource load-error Event). Served from public/gesture/.
|
||||
wasmBase: '/gesture/wasm',
|
||||
modelUrl: '/gesture/gesture_recognizer.task',
|
||||
});
|
||||
|
||||
this.gc.on('grab', (p) => this.onGrab(p.hand, p.x, p.y));
|
||||
this.gc.on('drag', (p) => this.onDrag(p.hand, p.x, p.y));
|
||||
this.gc.on('drop', (p) => this.onDrop(p.hand, p.x, p.y));
|
||||
this.gc.on('status', ({ fps, hands }) => this.onStatus(fps, hands));
|
||||
|
||||
this.button.addEventListener('click', () => void this.toggle());
|
||||
this.camBtn.addEventListener('click', () => this.toggleCamMode());
|
||||
}
|
||||
|
||||
private async toggle(): Promise<void> {
|
||||
if (this.running) {
|
||||
this.gc.stop();
|
||||
this.running = false;
|
||||
this.cancelAllGrabs();
|
||||
this.ctx.clearRect(0, 0, this.canvas.width, this.canvas.height);
|
||||
this.button.classList.remove('on');
|
||||
this.status.textContent = 'off';
|
||||
return;
|
||||
}
|
||||
this.button.disabled = true;
|
||||
this.status.textContent = 'starting…';
|
||||
try {
|
||||
await this.gc.start();
|
||||
this.running = true;
|
||||
this.button.classList.add('on');
|
||||
this.status.textContent = 'on — pinch a tab or button';
|
||||
} catch (err) {
|
||||
// Surface the *real* cause: MediaPipe/Emscripten can throw a non-Error
|
||||
// (number/string), so `(err as Error).message` was logging "undefined".
|
||||
const msg = describeError(err);
|
||||
this.status.textContent = `failed: ${msg}`;
|
||||
this.status.title = msg;
|
||||
console.error('[gesture] start failed', err);
|
||||
} finally {
|
||||
this.button.disabled = false;
|
||||
}
|
||||
}
|
||||
|
||||
private toggleCamMode(): void {
|
||||
this.camMode = this.camMode === 'full' ? 'pip' : 'full';
|
||||
this.applyCamMode();
|
||||
}
|
||||
|
||||
private applyCamMode(): void {
|
||||
this.video.classList.toggle('cg-full', this.camMode === 'full');
|
||||
this.video.classList.toggle('cg-pip', this.camMode === 'pip');
|
||||
}
|
||||
|
||||
/** Top-most element matching `sel` at a viewport point (overlays are
|
||||
* click-through, so elementFromPoint sees the dashboard beneath). */
|
||||
private hitClosest(x: number, y: number, sel: string): HTMLElement | null {
|
||||
const hit = document.elementFromPoint(x, y);
|
||||
return (hit?.closest(sel) as HTMLElement | null) ?? null;
|
||||
}
|
||||
|
||||
private onGrab(hand: string, x: number, y: number): void {
|
||||
// An existing floating panel → re-grab to move it (priority over tabs).
|
||||
// Make it click-through while held so elementFromPoint sees the dock zone
|
||||
// (and other content) beneath it, and it can't re-grab itself.
|
||||
const panelEl = this.hitClosest(x, y, PANEL_SELECTOR);
|
||||
const panelId = panelEl?.dataset.id;
|
||||
if (panelEl && panelId) {
|
||||
const float = this.floats.get(panelId);
|
||||
if (float) {
|
||||
const rect = panelEl.getBoundingClientRect();
|
||||
panelEl.style.pointerEvents = 'none';
|
||||
panelEl.classList.add('cg-float-grabbed');
|
||||
this.grabs.set(hand, {
|
||||
kind: 'panel',
|
||||
id: panelId,
|
||||
panel: float,
|
||||
dx: x - rect.left,
|
||||
dy: y - rect.top,
|
||||
overDock: false,
|
||||
});
|
||||
this.status.textContent = 'moving — drop over tabs to re-dock';
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
// A session tab → grab-and-pull-out into a floating panel (ghost follows).
|
||||
const tab = this.hitClosest(x, y, TAB_SELECTOR);
|
||||
const id = tab?.dataset.id;
|
||||
if (tab && id) {
|
||||
const rect = tab.getBoundingClientRect();
|
||||
const ghost = tab.cloneNode(true) as HTMLElement;
|
||||
ghost.classList.add('cg-ghost');
|
||||
ghost.removeAttribute('id');
|
||||
ghost.style.width = `${rect.width}px`;
|
||||
ghost.style.height = `${rect.height}px`;
|
||||
document.body.append(ghost);
|
||||
|
||||
tab.classList.add('cg-grabbed');
|
||||
this.grabs.set(hand, { kind: 'tab', id, tab, ghost, ox: x, oy: y, armed: false });
|
||||
this.positionGhost(ghost, x, y);
|
||||
return;
|
||||
}
|
||||
|
||||
// A toolbar button (Run / Run Shell) → tap-to-fire on release.
|
||||
const btn = this.hitClosest(x, y, CLICK_SELECTOR);
|
||||
if (btn) {
|
||||
const label = (btn.textContent || btn.getAttribute('title') || 'button').trim();
|
||||
btn.classList.add('cg-tap-armed');
|
||||
this.taps.set(hand, { el: btn, label, ox: x, oy: y });
|
||||
this.status.textContent = `release to ${label.toLowerCase()}`;
|
||||
}
|
||||
}
|
||||
|
||||
private onDrag(hand: string, x: number, y: number): void {
|
||||
const grab = this.grabs.get(hand);
|
||||
if (grab?.kind === 'tab') {
|
||||
this.positionGhost(grab.ghost, x, y);
|
||||
const pulled = Math.hypot(x - grab.ox, y - grab.oy) >= DETACH_PULL_PX;
|
||||
if (pulled !== grab.armed) {
|
||||
grab.armed = pulled;
|
||||
grab.ghost.classList.toggle('cg-armed', pulled);
|
||||
this.status.textContent = pulled ? 'release to float out' : 'on — pinch a tab';
|
||||
}
|
||||
return;
|
||||
}
|
||||
if (grab?.kind === 'panel') {
|
||||
this.moveFloat(grab.panel, x - grab.dx, y - grab.dy);
|
||||
const overDock = !!this.hitClosest(x, y, DOCK_SELECTOR);
|
||||
if (overDock !== grab.overDock) {
|
||||
grab.overDock = overDock;
|
||||
grab.panel.el.classList.toggle('cg-redock', overDock);
|
||||
this.status.textContent = overDock ? 'release to re-dock' : 'moving panel';
|
||||
}
|
||||
return;
|
||||
}
|
||||
// A button pinch that drifts too far is a stray move, not a tap — cancel it.
|
||||
const tap = this.taps.get(hand);
|
||||
if (tap && Math.hypot(x - tap.ox, y - tap.oy) > TAP_CANCEL_PX) {
|
||||
tap.el.classList.remove('cg-tap-armed');
|
||||
this.taps.delete(hand);
|
||||
this.status.textContent = 'on — pinch a tab or button';
|
||||
}
|
||||
}
|
||||
|
||||
private onDrop(hand: string, x: number, y: number): void {
|
||||
const grab = this.grabs.get(hand);
|
||||
if (grab?.kind === 'tab') {
|
||||
this.grabs.delete(hand);
|
||||
grab.ghost.remove();
|
||||
grab.tab.classList.remove('cg-grabbed');
|
||||
if (grab.armed) this.floatPanel(grab.id, x, y);
|
||||
else this.flash('cancelled');
|
||||
return;
|
||||
}
|
||||
if (grab?.kind === 'panel') {
|
||||
this.grabs.delete(hand);
|
||||
grab.panel.el.style.pointerEvents = ''; // interactive again (type into it)
|
||||
grab.panel.el.classList.remove('cg-float-grabbed', 'cg-redock');
|
||||
if (grab.overDock) this.redock(grab.id);
|
||||
else this.flash('placed');
|
||||
return;
|
||||
}
|
||||
// Release over the same button → fire its real click handler.
|
||||
const tap = this.taps.get(hand);
|
||||
if (tap) {
|
||||
this.taps.delete(hand);
|
||||
tap.el.classList.remove('cg-tap-armed');
|
||||
tap.el.click(); // runs the button's onclick (app.run() / app.runShell())
|
||||
this.flash(tap.label.toLowerCase());
|
||||
}
|
||||
}
|
||||
|
||||
/** Pop a session into an in-page floating panel (an iframe of its solo route)
|
||||
* centered on the drop point. Unlike OS-window detach, the panel lives in
|
||||
* this page's DOM, so the hand can re-grab and move it. Idempotent per id:
|
||||
* re-floating an existing id just repositions the panel it already has. */
|
||||
private floatPanel(id: string, x: number, y: number): void {
|
||||
let float = this.floats.get(id);
|
||||
if (!float) {
|
||||
const container = el('div', 'cg-float');
|
||||
container.dataset.id = id;
|
||||
const bar = el('div', 'cg-float-bar');
|
||||
bar.textContent = `session ${id}`;
|
||||
const frame = el('iframe', 'cg-float-frame') as HTMLIFrameElement;
|
||||
frame.src = `/session/${encodeURIComponent(id)}`;
|
||||
frame.title = `Session ${id}`;
|
||||
container.append(bar, frame);
|
||||
document.body.append(container);
|
||||
float = { id, el: container };
|
||||
this.floats.set(id, float);
|
||||
this.flash('floated out');
|
||||
} else {
|
||||
this.flash('re-floated');
|
||||
}
|
||||
this.moveFloat(float, x - FLOAT_W / 2, y - FLOAT_H / 2);
|
||||
}
|
||||
|
||||
/** Re-dock a floated session: drop its in-page panel. The original
|
||||
* `.session-tab` was never removed, so the session is simply back to plain
|
||||
* tab form. Mirrors Codeman's own `.detached` → attach toggle. */
|
||||
private redock(id: string): void {
|
||||
const float = this.floats.get(id);
|
||||
if (!float) return;
|
||||
float.el.remove();
|
||||
this.floats.delete(id);
|
||||
this.flash('re-docked');
|
||||
}
|
||||
|
||||
/** Position a float by its top-left corner, clamped to stay on-screen. */
|
||||
private moveFloat(float: FloatingPanel, left: number, top: number): void {
|
||||
const l = Math.min(Math.max(0, left), Math.max(0, window.innerWidth - FLOAT_W));
|
||||
const t = Math.min(Math.max(0, top), Math.max(0, window.innerHeight - FLOAT_H));
|
||||
float.el.style.left = `${l}px`;
|
||||
float.el.style.top = `${t}px`;
|
||||
}
|
||||
|
||||
private positionGhost(ghost: HTMLElement, x: number, y: number): void {
|
||||
ghost.style.left = `${x}px`;
|
||||
ghost.style.top = `${y}px`;
|
||||
}
|
||||
|
||||
private cancelAllGrabs(): void {
|
||||
// Floats themselves persist (they're placed windows) — only release any
|
||||
// in-progress grab cleanly, restoring a moved panel's interactivity.
|
||||
for (const grab of this.grabs.values()) {
|
||||
if (grab.kind === 'tab') {
|
||||
grab.ghost.remove();
|
||||
grab.tab.classList.remove('cg-grabbed');
|
||||
} else {
|
||||
grab.panel.el.style.pointerEvents = '';
|
||||
grab.panel.el.classList.remove('cg-float-grabbed', 'cg-redock');
|
||||
}
|
||||
}
|
||||
this.grabs.clear();
|
||||
for (const tap of this.taps.values()) tap.el.classList.remove('cg-tap-armed');
|
||||
this.taps.clear();
|
||||
document
|
||||
.querySelectorAll(`${TAB_SELECTOR}.cg-grabbed, .cg-tap-armed`)
|
||||
.forEach((t) => t.classList.remove('cg-grabbed', 'cg-tap-armed'));
|
||||
}
|
||||
|
||||
private onStatus(fps: number, hands: HandState[]): void {
|
||||
// Draw per-hand cursor dots (green while pinching) so the user can aim.
|
||||
const { width, height } = this.canvas;
|
||||
const dpr = window.devicePixelRatio || 1;
|
||||
this.ctx.clearRect(0, 0, width, height);
|
||||
const rect = this.surface.getBoundingClientRect();
|
||||
for (const h of hands) {
|
||||
const x = (1 - h.cursor.x) * rect.width;
|
||||
const y = h.cursor.y * rect.height;
|
||||
this.ctx.beginPath();
|
||||
this.ctx.arc(x * dpr, y * dpr, (h.pinching ? 14 : 9) * dpr, 0, Math.PI * 2);
|
||||
this.ctx.fillStyle = handColor(h.handedness, h.pinching);
|
||||
this.ctx.globalAlpha = 0.85;
|
||||
this.ctx.fill();
|
||||
this.ctx.globalAlpha = 1;
|
||||
}
|
||||
if (this.running && this.grabs.size === 0 && this.taps.size === 0) {
|
||||
this.status.textContent = `on · ${fps}fps`;
|
||||
}
|
||||
}
|
||||
|
||||
private flash(msg: string): void {
|
||||
this.status.textContent = msg;
|
||||
}
|
||||
|
||||
private sizeCanvas(): void {
|
||||
const dpr = window.devicePixelRatio || 1;
|
||||
this.canvas.width = Math.floor(window.innerWidth * dpr);
|
||||
this.canvas.height = Math.floor(window.innerHeight * dpr);
|
||||
}
|
||||
}
|
||||
|
||||
// ---- tiny helpers ------------------------------------------------------
|
||||
|
||||
function el(tag: string, className: string): HTMLElement {
|
||||
const node = document.createElement(tag);
|
||||
node.className = className;
|
||||
return node;
|
||||
}
|
||||
|
||||
/** Best-effort human-readable message for any thrown value (Error or not). */
|
||||
function describeError(err: unknown): string {
|
||||
if (err instanceof Error) return err.message || err.name || 'Error';
|
||||
if (typeof err === 'string') return err;
|
||||
if (typeof err === 'number') return `code ${err}`;
|
||||
if (err && typeof err === 'object') {
|
||||
const m = (err as { message?: unknown }).message;
|
||||
if (typeof m === 'string' && m) return m;
|
||||
try {
|
||||
return JSON.stringify(err);
|
||||
} catch {
|
||||
return Object.prototype.toString.call(err);
|
||||
}
|
||||
}
|
||||
return String(err);
|
||||
}
|
||||
|
||||
function injectStyles(): void {
|
||||
if (document.getElementById('cg-styles')) return;
|
||||
const css = `
|
||||
.cg-surface, .cg-canvas { position: fixed; inset: 0; pointer-events: none; }
|
||||
.cg-surface { z-index: ${Z}; }
|
||||
.cg-canvas { z-index: ${Z + 1}; width: 100vw; height: 100vh; }
|
||||
.cg-preview { transform: scaleX(-1); pointer-events: none; background: #000; }
|
||||
.cg-preview.cg-pip {
|
||||
position: fixed; right: 12px; bottom: 12px; width: 240px; height: 135px;
|
||||
object-fit: cover; border-radius: 8px; z-index: ${Z + 2};
|
||||
box-shadow: 0 4px 16px rgba(0,0,0,.5); opacity: 1;
|
||||
}
|
||||
.cg-preview.cg-full {
|
||||
position: fixed; inset: 0; width: 100vw; height: 100vh;
|
||||
object-fit: cover; opacity: .28; z-index: ${Z};
|
||||
}
|
||||
.cg-ghost {
|
||||
position: fixed; left: 0; top: 0; transform: translate(-50%, -50%) scale(1.06);
|
||||
z-index: ${Z + 2}; pointer-events: none; opacity: .92;
|
||||
box-shadow: 0 8px 28px rgba(0,0,0,.55); border-radius: 8px;
|
||||
outline: 2px solid #38bdf8; outline-offset: -2px;
|
||||
}
|
||||
.cg-ghost.cg-armed { outline-color: #4ade80; box-shadow: 0 8px 28px rgba(74,222,128,.5); }
|
||||
.cg-dock {
|
||||
position: fixed; right: 12px; bottom: 156px; z-index: ${Z + 3};
|
||||
display: flex; align-items: center; gap: 8px; font: 12px/1 system-ui, sans-serif;
|
||||
}
|
||||
.cg-btn {
|
||||
padding: 6px 12px; border-radius: 6px; border: 1px solid #3a3a40;
|
||||
background: #1b1b1f; color: #e5e5e7; cursor: pointer;
|
||||
}
|
||||
.cg-btn-icon { padding: 6px 9px; }
|
||||
.cg-btn.on { background: #16331f; border-color: #2f6b41; color: #4ade80; }
|
||||
.cg-status { color: #9aa0a6; max-width: 220px; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
|
||||
.session-tab.cg-grabbed { opacity: .35; outline: 2px dashed #4ade80; outline-offset: -2px; }
|
||||
.cg-tap-armed { outline: 2px solid #4ade80 !important; outline-offset: 2px; box-shadow: 0 0 0 4px rgba(74,222,128,.25) !important; }
|
||||
.cg-float {
|
||||
position: fixed; left: 0; top: 0; width: ${FLOAT_W}px; height: ${FLOAT_H}px;
|
||||
z-index: ${Z}; display: flex; flex-direction: column; overflow: hidden;
|
||||
background: #0c0c0f; border-radius: 10px; outline: 2px solid #38bdf8;
|
||||
outline-offset: -2px; box-shadow: 0 10px 40px rgba(0,0,0,.6);
|
||||
}
|
||||
.cg-float.cg-float-grabbed { outline-color: #4ade80; box-shadow: 0 12px 48px rgba(74,222,128,.45); }
|
||||
.cg-float.cg-redock { outline-color: #fbbf24; box-shadow: 0 12px 48px rgba(251,191,36,.5); }
|
||||
.cg-float-bar {
|
||||
flex: 0 0 auto; padding: 4px 10px; font: 11px/1.6 system-ui, sans-serif;
|
||||
color: #cbd5e1; background: #15151a; border-bottom: 1px solid #2a2a30;
|
||||
user-select: none; white-space: nowrap; overflow: hidden; text-overflow: ellipsis;
|
||||
}
|
||||
.cg-float-frame { flex: 1 1 auto; width: 100%; border: 0; background: #000; }
|
||||
`;
|
||||
const style = document.createElement('style');
|
||||
style.id = 'cg-styles';
|
||||
style.textContent = css;
|
||||
document.head.append(style);
|
||||
}
|
||||
|
||||
// Idempotent bootstrap — re-importing must not stack overlays.
|
||||
if (!window.__codemanGesture) {
|
||||
window.__codemanGesture = new GestureBridge();
|
||||
}
|
||||
@@ -0,0 +1,120 @@
|
||||
// Debug overlay: draws the 21-point hand skeleton over the (mirrored) video.
|
||||
//
|
||||
// The <video> is mirrored via CSS (transform: scaleX(-1)). To make the drawn
|
||||
// skeleton line up with what you see, we mirror the X coordinate here
|
||||
// (x_draw = (1 - x) * width) rather than CSS-mirroring the canvas — that keeps
|
||||
// any future text we draw readable.
|
||||
|
||||
import type { GestureRecognizerResult } from '@mediapipe/tasks-vision';
|
||||
import { HAND_CONNECTIONS } from '../gesture/landmarks.ts';
|
||||
|
||||
/** A cursor to draw: raw normalized position + base color + pinch state. */
|
||||
export interface CursorMark {
|
||||
x: number;
|
||||
y: number;
|
||||
color: string;
|
||||
pinching: boolean;
|
||||
}
|
||||
|
||||
export class Overlay {
|
||||
private ctx: CanvasRenderingContext2D;
|
||||
|
||||
constructor(
|
||||
private canvas: HTMLCanvasElement,
|
||||
private video: HTMLVideoElement
|
||||
) {
|
||||
const ctx = canvas.getContext('2d');
|
||||
if (!ctx) throw new Error('Could not get 2D context for overlay canvas');
|
||||
this.ctx = ctx;
|
||||
}
|
||||
|
||||
/** Match the canvas backing-store resolution to the displayed video size. */
|
||||
private syncSize(): void {
|
||||
const w = this.video.videoWidth || this.video.clientWidth;
|
||||
const h = this.video.videoHeight || this.video.clientHeight;
|
||||
if (w && h && (this.canvas.width !== w || this.canvas.height !== h)) {
|
||||
this.canvas.width = w;
|
||||
this.canvas.height = h;
|
||||
}
|
||||
}
|
||||
|
||||
clear(): void {
|
||||
this.ctx.clearRect(0, 0, this.canvas.width, this.canvas.height);
|
||||
}
|
||||
|
||||
/**
|
||||
* Draw the detected hands' skeletons plus one smoothed cursor per hand.
|
||||
* Cursor coords are raw normalized [0,1] (mirrored here, like the skeleton).
|
||||
*/
|
||||
draw(result: GestureRecognizerResult, cursors: CursorMark[] = []): void {
|
||||
this.syncSize();
|
||||
const { width: w, height: h } = this.canvas;
|
||||
const ctx = this.ctx;
|
||||
ctx.clearRect(0, 0, w, h);
|
||||
|
||||
const hands = result.landmarks ?? [];
|
||||
for (const landmarks of hands) {
|
||||
// Connections (bones)
|
||||
ctx.strokeStyle = 'rgba(80, 220, 255, 0.9)';
|
||||
ctx.lineWidth = 3;
|
||||
for (const [a, b] of HAND_CONNECTIONS) {
|
||||
const pa = landmarks[a];
|
||||
const pb = landmarks[b];
|
||||
if (!pa || !pb) continue;
|
||||
ctx.beginPath();
|
||||
ctx.moveTo((1 - pa.x) * w, pa.y * h);
|
||||
ctx.lineTo((1 - pb.x) * w, pb.y * h);
|
||||
ctx.stroke();
|
||||
}
|
||||
|
||||
// Joints (points)
|
||||
for (let i = 0; i < landmarks.length; i++) {
|
||||
const p = landmarks[i];
|
||||
const x = (1 - p.x) * w;
|
||||
const y = p.y * h;
|
||||
// Highlight thumb tip (4) + index tip (8) — these drive the cursor later.
|
||||
const isPinchPoint = i === 4 || i === 8;
|
||||
ctx.fillStyle = isPinchPoint ? '#ffd166' : '#ff5d8f';
|
||||
ctx.beginPath();
|
||||
ctx.arc(x, y, isPinchPoint ? 7 : 4, 0, Math.PI * 2);
|
||||
ctx.fill();
|
||||
}
|
||||
}
|
||||
|
||||
for (const c of cursors) this.drawCursor(c, w, h);
|
||||
}
|
||||
|
||||
/** A ring + crosshair at the cursor; green + filled while pinching. */
|
||||
private drawCursor(cursor: CursorMark, w: number, h: number): void {
|
||||
const ctx = this.ctx;
|
||||
const cx = (1 - cursor.x) * w; // mirror X to match the displayed video
|
||||
const cy = cursor.y * h;
|
||||
const pinching = cursor.pinching;
|
||||
const r = pinching ? 16 : 12;
|
||||
const color = pinching ? '#4ade80' : cursor.color;
|
||||
|
||||
if (pinching) {
|
||||
ctx.fillStyle = 'rgba(74, 222, 128, 0.25)';
|
||||
ctx.beginPath();
|
||||
ctx.arc(cx, cy, r, 0, Math.PI * 2);
|
||||
ctx.fill();
|
||||
}
|
||||
|
||||
ctx.strokeStyle = color;
|
||||
ctx.lineWidth = 3;
|
||||
ctx.beginPath();
|
||||
ctx.arc(cx, cy, r, 0, Math.PI * 2);
|
||||
ctx.stroke();
|
||||
|
||||
ctx.beginPath();
|
||||
ctx.moveTo(cx - r - 5, cy);
|
||||
ctx.lineTo(cx - r + 4, cy);
|
||||
ctx.moveTo(cx + r - 4, cy);
|
||||
ctx.lineTo(cx + r + 5, cy);
|
||||
ctx.moveTo(cx, cy - r - 5);
|
||||
ctx.lineTo(cx, cy - r + 4);
|
||||
ctx.moveTo(cx, cy + r - 4);
|
||||
ctx.lineTo(cx, cy + r + 5);
|
||||
ctx.stroke();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,209 @@
|
||||
// demo/tabs.ts — Phase 3 fake-tab board.
|
||||
//
|
||||
// 3 columns of draggable "session" tabs, driven entirely by gesture events
|
||||
// (no mouse). The board overlays the camera stage, so surface-pixel coords
|
||||
// from GestureController map straight onto board-local coords.
|
||||
//
|
||||
// Source of truth for which tab is in which column is the DOM itself. The
|
||||
// state machine here is tiny: grab → (drag)* → drop, tracked per hand so two
|
||||
// hands can drag two tabs at once.
|
||||
|
||||
interface Tab {
|
||||
id: string;
|
||||
el: HTMLElement;
|
||||
}
|
||||
|
||||
interface Column {
|
||||
id: string;
|
||||
title: string;
|
||||
el: HTMLElement;
|
||||
list: HTMLElement;
|
||||
}
|
||||
|
||||
interface Grab {
|
||||
tab: Tab;
|
||||
originList: HTMLElement;
|
||||
w: number;
|
||||
h: number;
|
||||
}
|
||||
|
||||
/** A hovering cursor for highlight purposes. */
|
||||
export interface HoverPoint {
|
||||
x: number;
|
||||
y: number;
|
||||
pinching: boolean;
|
||||
}
|
||||
|
||||
const INITIAL: Array<{ id: string; title: string; tabs: string[] }> = [
|
||||
{ id: 'screen-1', title: 'Screen 1', tabs: ['auth-refactor', 'api-tests'] },
|
||||
{ id: 'screen-2', title: 'Screen 2', tabs: ['db-migrate', 'ui-polish', 'docs'] },
|
||||
{ id: 'screen-3', title: 'Screen 3', tabs: ['ci-fix'] },
|
||||
];
|
||||
|
||||
export class TabsBoard {
|
||||
private columns: Column[] = [];
|
||||
private tabs = new Map<string, Tab>();
|
||||
/** hand id → the tab it is currently dragging. */
|
||||
private grabs = new Map<string, Grab>();
|
||||
|
||||
/** @param onDrop notified after a settled drop: (tab, column or null if cancelled). */
|
||||
constructor(
|
||||
private root: HTMLElement,
|
||||
private onDrop?: (tabId: string, columnId: string | null) => void
|
||||
) {
|
||||
this.build();
|
||||
}
|
||||
|
||||
private build(): void {
|
||||
this.root.classList.add('board');
|
||||
for (const col of INITIAL) {
|
||||
const el = document.createElement('div');
|
||||
el.className = 'column';
|
||||
el.dataset.col = col.id;
|
||||
|
||||
const header = document.createElement('header');
|
||||
header.textContent = col.title;
|
||||
|
||||
const list = document.createElement('div');
|
||||
list.className = 'tablist';
|
||||
|
||||
el.append(header, list);
|
||||
this.root.append(el);
|
||||
this.columns.push({ id: col.id, title: col.title, el, list });
|
||||
|
||||
for (const id of col.tabs) {
|
||||
const tab = this.makeTab(id);
|
||||
list.append(tab.el);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private makeTab(id: string): Tab {
|
||||
const el = document.createElement('div');
|
||||
el.className = 'tab';
|
||||
el.dataset.tab = id;
|
||||
el.textContent = id;
|
||||
const tab: Tab = { id, el };
|
||||
this.tabs.set(id, tab);
|
||||
return tab;
|
||||
}
|
||||
|
||||
// ---- Geometry --------------------------------------------------------
|
||||
|
||||
/** Element rect in board-local coords (origin = board top-left). */
|
||||
private localRect(el: HTMLElement): DOMRect {
|
||||
const r = el.getBoundingClientRect();
|
||||
const base = this.root.getBoundingClientRect();
|
||||
return new DOMRect(r.left - base.left, r.top - base.top, r.width, r.height);
|
||||
}
|
||||
|
||||
/** Hit-test slop (px). Cursor jitter + a small target shouldn't fight you. */
|
||||
private static readonly GRAB_PAD = 18;
|
||||
|
||||
private static contains(r: DOMRect, x: number, y: number, pad = 0): boolean {
|
||||
return x >= r.left - pad && x <= r.right + pad && y >= r.top - pad && y <= r.bottom + pad;
|
||||
}
|
||||
|
||||
private columnAt(x: number, y: number): Column | null {
|
||||
for (const c of this.columns) {
|
||||
if (TabsBoard.contains(this.localRect(c.el), x, y)) return c;
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
/** Topmost ungrabbed tab under the point. Nearest-center wins ties so the
|
||||
* padded hit-areas of adjacent tabs resolve to the most likely target. */
|
||||
private tabAt(x: number, y: number): Tab | null {
|
||||
let best: Tab | null = null;
|
||||
let bestDist = Infinity;
|
||||
for (const tab of this.tabs.values()) {
|
||||
if (this.isGrabbed(tab.id)) continue;
|
||||
const r = this.localRect(tab.el);
|
||||
if (!TabsBoard.contains(r, x, y, TabsBoard.GRAB_PAD)) continue;
|
||||
const cx = r.left + r.width / 2;
|
||||
const cy = r.top + r.height / 2;
|
||||
const d = (x - cx) ** 2 + (y - cy) ** 2;
|
||||
if (d < bestDist) {
|
||||
bestDist = d;
|
||||
best = tab;
|
||||
}
|
||||
}
|
||||
return best;
|
||||
}
|
||||
|
||||
private isGrabbed(tabId: string): boolean {
|
||||
for (const g of this.grabs.values()) if (g.tab.id === tabId) return true;
|
||||
return false;
|
||||
}
|
||||
|
||||
// ---- Highlights (driven each frame from the status snapshot) ---------
|
||||
|
||||
/** Recompute hover highlights from the full set of present cursors. */
|
||||
hover(points: HoverPoint[]): void {
|
||||
this.root.querySelectorAll('.col-hot, .tab-hot').forEach((el) => el.classList.remove('col-hot', 'tab-hot'));
|
||||
|
||||
for (const p of points) {
|
||||
this.columnAt(p.x, p.y)?.el.classList.add('col-hot');
|
||||
// Only show a grab affordance when the hand is open (not pinching).
|
||||
if (!p.pinching) this.tabAt(p.x, p.y)?.el.classList.add('tab-hot');
|
||||
}
|
||||
}
|
||||
|
||||
// ---- Drag state machine ---------------------------------------------
|
||||
|
||||
grab(hand: string, x: number, y: number): void {
|
||||
if (this.grabs.has(hand)) return;
|
||||
const tab = this.tabAt(x, y);
|
||||
if (!tab) return;
|
||||
|
||||
const rect = this.localRect(tab.el);
|
||||
this.grabs.set(hand, {
|
||||
tab,
|
||||
originList: tab.el.parentElement as HTMLElement,
|
||||
w: rect.width,
|
||||
h: rect.height,
|
||||
});
|
||||
tab.el.classList.add('dragging');
|
||||
tab.el.style.width = `${rect.width}px`;
|
||||
// Reparent the floating tab onto the board root before positioning it.
|
||||
// A `.column` can't be the containing block: its `backdrop-filter` makes it
|
||||
// the containing block for absolutely-positioned children, so our
|
||||
// board-local left/top would be offset by the column's own position (tabs
|
||||
// in the middle/right columns flew off to the right). #board has no
|
||||
// filter/transform, so it's a stable origin that matches moveTo's coords.
|
||||
this.root.append(tab.el);
|
||||
this.moveTo(tab.el, x, y, rect.width, rect.height);
|
||||
}
|
||||
|
||||
drag(hand: string, x: number, y: number): void {
|
||||
const g = this.grabs.get(hand);
|
||||
if (!g) return;
|
||||
this.moveTo(g.tab.el, x, y, g.w, g.h);
|
||||
}
|
||||
|
||||
drop(hand: string, x: number, y: number): void {
|
||||
const g = this.grabs.get(hand);
|
||||
if (!g) return;
|
||||
this.grabs.delete(hand);
|
||||
|
||||
const target = this.columnAt(x, y);
|
||||
const dest = target ? target.list : g.originList;
|
||||
dest.append(g.tab.el);
|
||||
|
||||
g.tab.el.classList.remove('dragging');
|
||||
g.tab.el.style.removeProperty('width');
|
||||
g.tab.el.style.removeProperty('left');
|
||||
g.tab.el.style.removeProperty('top');
|
||||
|
||||
this.onDrop?.(g.tab.id, target ? target.id : null);
|
||||
}
|
||||
|
||||
/** Center the floating tab on the cursor (clamped to the board). */
|
||||
private moveTo(el: HTMLElement, x: number, y: number, w: number, h: number): void {
|
||||
const base = this.root.getBoundingClientRect();
|
||||
const left = Math.max(0, Math.min(x - w / 2, base.width - w));
|
||||
const top = Math.max(0, Math.min(y - h / 2, base.height - h));
|
||||
el.style.left = `${left}px`;
|
||||
el.style.top = `${top}px`;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,386 @@
|
||||
// GestureController — core input layer.
|
||||
//
|
||||
// Phase 0/1 scope (this file currently implements):
|
||||
// - Open the webcam (getUserMedia) and attach it to a <video>.
|
||||
// - Load MediaPipe GestureRecognizer in VIDEO mode (wasm + .task from CDN).
|
||||
// - Run a requestAnimationFrame loop calling recognizeForVideo().
|
||||
// - Emit `status` (fps / handPresent / gesture) and `results` (raw, debug).
|
||||
//
|
||||
// Later phases add the cursor (One-Euro filtered), pinch hysteresis, the
|
||||
// hover/grab/drag/drop state machine, and the discrete gesture command bus.
|
||||
// The event surface in types.ts already declares those so the API is stable.
|
||||
|
||||
import { FilesetResolver, GestureRecognizer, type GestureRecognizerResult } from '@mediapipe/tasks-vision';
|
||||
import type {
|
||||
GestureControllerOptions,
|
||||
GestureEventHandler,
|
||||
GestureEventMap,
|
||||
GestureEventName,
|
||||
HandState,
|
||||
} from './types.ts';
|
||||
import { LANDMARK, midpoint } from './landmarks.ts';
|
||||
import { OneEuroFilter } from './OneEuroFilter.ts';
|
||||
import { PinchDetector, pinchDistance } from './pinch.ts';
|
||||
import { CommandDetector } from './commands.ts';
|
||||
|
||||
const DEFAULTS = {
|
||||
numHands: 1,
|
||||
deviceId: '',
|
||||
pinchOn: 0.35,
|
||||
pinchOff: 0.5,
|
||||
minCutoff: 1.0,
|
||||
beta: 0.01,
|
||||
palmHoldMs: 1000,
|
||||
minDetectionConfidence: 0.6,
|
||||
minTrackingConfidence: 0.6,
|
||||
// Pinned to the @mediapipe/tasks-vision version in package.json.
|
||||
wasmBase: 'https://cdn.jsdelivr.net/npm/@mediapipe/tasks-vision@0.10.21/wasm',
|
||||
modelUrl:
|
||||
'https://storage.googleapis.com/mediapipe-models/gesture_recognizer/gesture_recognizer/float16/1/gesture_recognizer.task',
|
||||
} as const;
|
||||
|
||||
interface PerHandState {
|
||||
cursorX: OneEuroFilter;
|
||||
cursorY: OneEuroFilter;
|
||||
pinch: PinchDetector;
|
||||
/** Original handedness label (the map key may be disambiguated). */
|
||||
label: string;
|
||||
/** Last emitted surface-pixel position, so we can drop on a vanished hand. */
|
||||
lastX: number;
|
||||
lastY: number;
|
||||
}
|
||||
|
||||
export class GestureController {
|
||||
private readonly opts: Required<GestureControllerOptions>;
|
||||
private recognizer: GestureRecognizer | null = null;
|
||||
private stream: MediaStream | null = null;
|
||||
private rafId: number | null = null;
|
||||
private running = false;
|
||||
|
||||
// Timestamps must be strictly increasing for recognizeForVideo.
|
||||
private lastVideoTime = -1;
|
||||
private lastTimestamp = -1;
|
||||
|
||||
// FPS tracking (rolling over a short window).
|
||||
private frameTimes: number[] = [];
|
||||
|
||||
// Per-hand smoothing + pinch state, keyed by handedness ("Left"/"Right") so a
|
||||
// hand keeps its own filters even when MediaPipe reorders the hands array.
|
||||
private readonly handStates = new Map<string, PerHandState>();
|
||||
|
||||
// Discrete gesture → command bus (debounced; Open_Palm held = halt-all).
|
||||
private readonly commands: CommandDetector;
|
||||
|
||||
// Internal storage is intentionally loose; the public on/off/emit signatures
|
||||
// below keep callers fully type-safe per event name.
|
||||
private listeners: Partial<Record<GestureEventName, Set<(payload: unknown) => void>>> = {};
|
||||
|
||||
constructor(options: GestureControllerOptions) {
|
||||
this.opts = {
|
||||
surface: options.surface ?? options.video,
|
||||
numHands: options.numHands ?? DEFAULTS.numHands,
|
||||
deviceId: options.deviceId ?? DEFAULTS.deviceId,
|
||||
pinchOn: options.pinchOn ?? DEFAULTS.pinchOn,
|
||||
pinchOff: options.pinchOff ?? DEFAULTS.pinchOff,
|
||||
minCutoff: options.minCutoff ?? DEFAULTS.minCutoff,
|
||||
beta: options.beta ?? DEFAULTS.beta,
|
||||
palmHoldMs: options.palmHoldMs ?? DEFAULTS.palmHoldMs,
|
||||
minDetectionConfidence: options.minDetectionConfidence ?? DEFAULTS.minDetectionConfidence,
|
||||
minTrackingConfidence: options.minTrackingConfidence ?? DEFAULTS.minTrackingConfidence,
|
||||
wasmBase: options.wasmBase ?? DEFAULTS.wasmBase,
|
||||
modelUrl: options.modelUrl ?? DEFAULTS.modelUrl,
|
||||
video: options.video,
|
||||
};
|
||||
|
||||
this.commands = new CommandDetector(this.opts.palmHoldMs);
|
||||
}
|
||||
|
||||
/** Get (or lazily create) the smoothing + pinch state for one hand. */
|
||||
private handState(key: string): PerHandState {
|
||||
let state = this.handStates.get(key);
|
||||
if (!state) {
|
||||
state = {
|
||||
cursorX: new OneEuroFilter(this.opts.minCutoff, this.opts.beta),
|
||||
cursorY: new OneEuroFilter(this.opts.minCutoff, this.opts.beta),
|
||||
pinch: new PinchDetector(this.opts.pinchOn, this.opts.pinchOff),
|
||||
label: key,
|
||||
lastX: 0,
|
||||
lastY: 0,
|
||||
};
|
||||
this.handStates.set(key, state);
|
||||
}
|
||||
return state;
|
||||
}
|
||||
|
||||
// ---- Event emitter ---------------------------------------------------
|
||||
|
||||
on<K extends GestureEventName>(event: K, handler: GestureEventHandler<K>): this {
|
||||
(this.listeners[event] ??= new Set()).add(handler as (payload: unknown) => void);
|
||||
return this;
|
||||
}
|
||||
|
||||
off<K extends GestureEventName>(event: K, handler: GestureEventHandler<K>): this {
|
||||
this.listeners[event]?.delete(handler as (payload: unknown) => void);
|
||||
return this;
|
||||
}
|
||||
|
||||
private emit<K extends GestureEventName>(event: K, payload: GestureEventMap[K]): void {
|
||||
this.listeners[event]?.forEach((h) => h(payload));
|
||||
}
|
||||
|
||||
// ---- Lifecycle -------------------------------------------------------
|
||||
|
||||
/** Request the camera, load the model, and start the recognition loop. */
|
||||
async start(): Promise<void> {
|
||||
if (this.running) return;
|
||||
|
||||
await this.openCamera();
|
||||
await this.loadRecognizer();
|
||||
|
||||
this.running = true;
|
||||
this.lastVideoTime = -1;
|
||||
this.lastTimestamp = -1;
|
||||
this.frameTimes = [];
|
||||
this.handStates.clear();
|
||||
this.commands.reset();
|
||||
this.loop();
|
||||
}
|
||||
|
||||
/** Stop the loop, release the camera, and close the recognizer. */
|
||||
stop(): void {
|
||||
this.running = false;
|
||||
if (this.rafId !== null) {
|
||||
cancelAnimationFrame(this.rafId);
|
||||
this.rafId = null;
|
||||
}
|
||||
if (this.stream) {
|
||||
this.stream.getTracks().forEach((t) => t.stop());
|
||||
this.stream = null;
|
||||
}
|
||||
this.opts.video.srcObject = null;
|
||||
this.recognizer?.close();
|
||||
this.recognizer = null;
|
||||
}
|
||||
|
||||
/** The camera currently in use (resolved deviceId), or "" if not started. */
|
||||
get deviceId(): string {
|
||||
return this.opts.deviceId;
|
||||
}
|
||||
|
||||
/** List available video input devices. Labels are only populated once the
|
||||
* user has granted camera permission (i.e. after the first start()). */
|
||||
async listCameras(): Promise<MediaDeviceInfo[]> {
|
||||
const devices = await navigator.mediaDevices.enumerateDevices();
|
||||
return devices.filter((d) => d.kind === 'videoinput');
|
||||
}
|
||||
|
||||
/** Switch to a different camera. Reopens the stream live if already running. */
|
||||
async useCamera(deviceId: string): Promise<void> {
|
||||
this.opts.deviceId = deviceId;
|
||||
if (!this.running) return;
|
||||
if (this.stream) {
|
||||
this.stream.getTracks().forEach((t) => t.stop());
|
||||
this.stream = null;
|
||||
}
|
||||
await this.openCamera();
|
||||
// Fresh camera = fresh geometry; drop stale filter state to avoid a snap.
|
||||
this.handStates.clear();
|
||||
this.lastVideoTime = -1;
|
||||
}
|
||||
|
||||
// ---- Setup -----------------------------------------------------------
|
||||
|
||||
private async openCamera(): Promise<void> {
|
||||
if (!navigator.mediaDevices?.getUserMedia) {
|
||||
throw new Error('getUserMedia is not available (needs a secure context).');
|
||||
}
|
||||
const videoConstraints: MediaTrackConstraints = {
|
||||
width: { ideal: 1280 },
|
||||
height: { ideal: 720 },
|
||||
frameRate: { ideal: 60, max: 60 },
|
||||
};
|
||||
// A specific device wins; otherwise ask for the user-facing camera.
|
||||
if (this.opts.deviceId) videoConstraints.deviceId = { exact: this.opts.deviceId };
|
||||
else videoConstraints.facingMode = 'user';
|
||||
|
||||
const stream = await navigator.mediaDevices.getUserMedia({
|
||||
video: videoConstraints,
|
||||
audio: false,
|
||||
});
|
||||
this.stream = stream;
|
||||
// Record the resolved device so callers can pre-select it in a UI.
|
||||
this.opts.deviceId = stream.getVideoTracks()[0]?.getSettings().deviceId ?? this.opts.deviceId;
|
||||
const video = this.opts.video;
|
||||
video.srcObject = stream;
|
||||
video.muted = true;
|
||||
video.playsInline = true;
|
||||
await video.play();
|
||||
|
||||
// Wait until dimensions are known so the overlay can size itself.
|
||||
if (!video.videoWidth) {
|
||||
await new Promise<void>((resolve) => {
|
||||
const onMeta = () => {
|
||||
video.removeEventListener('loadedmetadata', onMeta);
|
||||
resolve();
|
||||
};
|
||||
video.addEventListener('loadedmetadata', onMeta);
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
private async loadRecognizer(): Promise<void> {
|
||||
const fileset = await FilesetResolver.forVisionTasks(this.opts.wasmBase);
|
||||
const build = (delegate: 'GPU' | 'CPU') =>
|
||||
GestureRecognizer.createFromOptions(fileset, {
|
||||
baseOptions: {
|
||||
modelAssetPath: this.opts.modelUrl,
|
||||
delegate,
|
||||
},
|
||||
runningMode: 'VIDEO',
|
||||
numHands: this.opts.numHands,
|
||||
minHandDetectionConfidence: this.opts.minDetectionConfidence,
|
||||
minHandPresenceConfidence: this.opts.minDetectionConfidence,
|
||||
minTrackingConfidence: this.opts.minTrackingConfidence,
|
||||
});
|
||||
// GPU is the fast path (60fps on the MacBook). But some environments fail to
|
||||
// init the GPU delegate — and MediaPipe/Emscripten often throws a *non-Error*
|
||||
// value there (a raw number/string), which surfaces upstream as a useless
|
||||
// "failed: undefined". Fall back to CPU so the recognizer still starts.
|
||||
try {
|
||||
this.recognizer = await build('GPU');
|
||||
} catch (err) {
|
||||
console.warn('[gesture] GPU delegate failed; falling back to CPU.', err);
|
||||
this.recognizer = await build('CPU');
|
||||
}
|
||||
}
|
||||
|
||||
// ---- Loop ------------------------------------------------------------
|
||||
|
||||
private loop = (): void => {
|
||||
if (!this.running || !this.recognizer) return;
|
||||
this.rafId = requestAnimationFrame(this.loop);
|
||||
|
||||
const video = this.opts.video;
|
||||
if (video.readyState < 2 /* HAVE_CURRENT_DATA */) return;
|
||||
|
||||
// Strictly increasing timestamp in ms.
|
||||
let ts = performance.now();
|
||||
if (ts <= this.lastTimestamp) ts = this.lastTimestamp + 1;
|
||||
this.lastTimestamp = ts;
|
||||
|
||||
// Only re-run inference when the video frame actually advanced.
|
||||
if (video.currentTime === this.lastVideoTime) return;
|
||||
this.lastVideoTime = video.currentTime;
|
||||
|
||||
let result: GestureRecognizerResult;
|
||||
try {
|
||||
result = this.recognizer.recognizeForVideo(video, ts);
|
||||
} catch (err) {
|
||||
console.error('recognizeForVideo failed', err);
|
||||
return;
|
||||
}
|
||||
|
||||
this.trackFps(ts);
|
||||
this.publish(result, ts);
|
||||
};
|
||||
|
||||
private trackFps(nowMs: number): void {
|
||||
this.frameTimes.push(nowMs);
|
||||
const windowStart = nowMs - 1000;
|
||||
while (this.frameTimes.length && this.frameTimes[0] < windowStart) {
|
||||
this.frameTimes.shift();
|
||||
}
|
||||
}
|
||||
|
||||
private get fps(): number {
|
||||
if (this.frameTimes.length < 2) return 0;
|
||||
const span = this.frameTimes[this.frameTimes.length - 1] - this.frameTimes[0];
|
||||
if (span <= 0) return 0;
|
||||
return Math.round(((this.frameTimes.length - 1) / span) * 1000);
|
||||
}
|
||||
|
||||
private publish(result: GestureRecognizerResult, ts: number): void {
|
||||
const allLandmarks = result.landmarks ?? [];
|
||||
const handedness = result.handedness ?? [];
|
||||
const gestures = result.gestures ?? [];
|
||||
const tSec = ts / 1000;
|
||||
|
||||
// Surface rect → maps normalized [0,1] coords to surface pixels (X mirrored).
|
||||
const rect = this.opts.surface.getBoundingClientRect();
|
||||
|
||||
const hands: HandState[] = [];
|
||||
const activeKeys = new Set<string>();
|
||||
|
||||
for (let i = 0; i < allLandmarks.length; i++) {
|
||||
const lm = allLandmarks[i];
|
||||
if (!lm || lm.length === 0) continue;
|
||||
|
||||
// Key by handedness so each hand keeps its own filters across frames.
|
||||
// Fall back to index, and disambiguate if both hands share a label.
|
||||
const label = handedness[i]?.[0]?.categoryName ?? `hand${i}`;
|
||||
let key = label;
|
||||
if (activeKeys.has(key)) key = `${label}#${i}`;
|
||||
activeKeys.add(key);
|
||||
|
||||
const state = this.handState(key);
|
||||
const mid = midpoint(lm[LANDMARK.THUMB_TIP], lm[LANDMARK.INDEX_TIP]);
|
||||
const cursor = {
|
||||
x: state.cursorX.filter(mid.x, tSec),
|
||||
y: state.cursorY.filter(mid.y, tSec),
|
||||
};
|
||||
const pinchDist = pinchDistance(lm);
|
||||
const changed = state.pinch.update(pinchDist);
|
||||
const gesture = gestures[i]?.[0]?.categoryName ?? null;
|
||||
|
||||
// Pinch state machine → discrete drag events in surface pixels.
|
||||
const sx = (1 - cursor.x) * rect.width;
|
||||
const sy = cursor.y * rect.height;
|
||||
state.lastX = sx;
|
||||
state.lastY = sy;
|
||||
const pointer = { hand: label, x: sx, y: sy };
|
||||
if (state.pinch.isPinching) {
|
||||
this.emit(changed ? 'grab' : 'drag', pointer);
|
||||
} else if (changed) {
|
||||
this.emit('drop', pointer);
|
||||
}
|
||||
|
||||
hands.push({
|
||||
handedness: label,
|
||||
cursor,
|
||||
pinchDist,
|
||||
pinching: state.pinch.isPinching,
|
||||
gesture: gesture && gesture !== 'None' ? gesture : null,
|
||||
});
|
||||
}
|
||||
|
||||
// Drop state for hands that vanished, so a returning hand starts fresh
|
||||
// (no snap from a stale filter position) and the map can't grow unbounded.
|
||||
// If a vanished hand was mid-pinch, emit a drop so nothing stays grabbed.
|
||||
for (const key of [...this.handStates.keys()]) {
|
||||
if (activeKeys.has(key)) continue;
|
||||
const stale = this.handStates.get(key)!;
|
||||
if (stale.pinch.isPinching) {
|
||||
this.emit('drop', { hand: stale.label, x: stale.lastX, y: stale.lastY });
|
||||
}
|
||||
this.handStates.delete(key);
|
||||
}
|
||||
|
||||
// Discrete commands come from open-hand gestures; ignore a hand that's
|
||||
// pinching (mid-drag) so a drag can't be misread as a command.
|
||||
const commandGestures = new Set<string>();
|
||||
for (const h of hands) {
|
||||
if (!h.pinching && h.gesture) commandGestures.add(h.gesture);
|
||||
}
|
||||
for (const name of this.commands.update(commandGestures, ts)) {
|
||||
this.emit('command', { name });
|
||||
}
|
||||
|
||||
// Status first so the overlay can read this frame's cursors in `results`.
|
||||
this.emit('status', {
|
||||
fps: this.fps,
|
||||
hands,
|
||||
haltProgress: this.commands.haltProgress(ts),
|
||||
});
|
||||
this.emit('results', { result, timestampMs: ts });
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,73 @@
|
||||
// One-Euro filter — low-latency smoothing for noisy interactive signals.
|
||||
// Heavy smoothing when the value is still (kills jitter), low lag when it moves
|
||||
// fast. The correct tool for raw landmark streams, which jitter several pixels
|
||||
// even when the hand is held still.
|
||||
//
|
||||
// Reference: Casiez, Roussel, Vogel — "1€ Filter" (CHI 2012),
|
||||
// http://cristal.univ-lille.fr/~casiez/1euro/
|
||||
//
|
||||
// One filter handles a single scalar; use one instance per axis (x, y).
|
||||
|
||||
/** Smoothing factor for a low-pass step given a cutoff (Hz) and timestep (s). */
|
||||
function smoothingAlpha(cutoffHz: number, dtSec: number): number {
|
||||
const tau = 1 / (2 * Math.PI * cutoffHz);
|
||||
return 1 / (1 + tau / dtSec);
|
||||
}
|
||||
|
||||
/** Exponential low-pass that remembers its last output. */
|
||||
class LowPass {
|
||||
private value: number | null = null;
|
||||
|
||||
filter(x: number, alpha: number): number {
|
||||
this.value = this.value === null ? x : alpha * x + (1 - alpha) * this.value;
|
||||
return this.value;
|
||||
}
|
||||
|
||||
reset(): void {
|
||||
this.value = null;
|
||||
}
|
||||
|
||||
get initialized(): boolean {
|
||||
return this.value !== null;
|
||||
}
|
||||
}
|
||||
|
||||
export class OneEuroFilter {
|
||||
private readonly signal = new LowPass();
|
||||
private readonly derivative = new LowPass();
|
||||
private lastTimeSec: number | null = null;
|
||||
private lastRaw = 0;
|
||||
|
||||
/**
|
||||
* @param minCutoff Baseline cutoff (Hz). Lower → smoother but laggier when still.
|
||||
* @param beta Speed coefficient. Higher → less lag during fast moves.
|
||||
* @param dCutoff Cutoff for the derivative low-pass (Hz). 1.0 is fine.
|
||||
*/
|
||||
constructor(
|
||||
private minCutoff = 1.0,
|
||||
private beta = 0.01,
|
||||
private dCutoff = 1.0
|
||||
) {}
|
||||
|
||||
reset(): void {
|
||||
this.signal.reset();
|
||||
this.derivative.reset();
|
||||
this.lastTimeSec = null;
|
||||
this.lastRaw = 0;
|
||||
}
|
||||
|
||||
/** @param timeSec strictly-increasing timestamp in seconds. */
|
||||
filter(x: number, timeSec: number): number {
|
||||
let dt = this.lastTimeSec === null ? 1 / 60 : timeSec - this.lastTimeSec;
|
||||
if (dt <= 0) dt = 1 / 60;
|
||||
this.lastTimeSec = timeSec;
|
||||
|
||||
// Rate of change, itself low-passed, drives the adaptive cutoff.
|
||||
const dRaw = this.signal.initialized ? (x - this.lastRaw) / dt : 0;
|
||||
this.lastRaw = x;
|
||||
const edRaw = this.derivative.filter(dRaw, smoothingAlpha(this.dCutoff, dt));
|
||||
|
||||
const cutoff = this.minCutoff + this.beta * Math.abs(edRaw);
|
||||
return this.signal.filter(x, smoothingAlpha(cutoff, dt));
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,78 @@
|
||||
// Discrete gesture → command detection.
|
||||
//
|
||||
// Maps the recognizer's canned gesture categories onto Codeman commands, with
|
||||
// debouncing so each command fires once per gesture *entry* (not every frame
|
||||
// while it's held). Open_Palm is special: it must be held continuously for
|
||||
// `palmHoldMs` before firing halt-all — a dead-man's-switch that's hard to
|
||||
// trigger by accident, since pausing every session is a big hammer.
|
||||
|
||||
import type { CommandName } from './types.ts';
|
||||
|
||||
interface CommandSpec {
|
||||
name: CommandName;
|
||||
/** If set, the gesture must be held this long (ms) before it fires. */
|
||||
holdMs?: number;
|
||||
}
|
||||
|
||||
/** MediaPipe canned gesture category → command. */
|
||||
const GESTURE_COMMANDS: Record<string, CommandSpec> = {
|
||||
Open_Palm: { name: 'halt-all', holdMs: -1 }, // holdMs filled from palmHoldMs
|
||||
Thumb_Up: { name: 'approve' },
|
||||
Victory: { name: 'new-session' },
|
||||
};
|
||||
|
||||
export class CommandDetector {
|
||||
/** gesture category → timestamp (ms) it was first seen in the current hold. */
|
||||
private heldSince = new Map<string, number>();
|
||||
/** gestures that already fired during the current hold (cleared on release). */
|
||||
private fired = new Set<string>();
|
||||
|
||||
constructor(private palmHoldMs = 1000) {}
|
||||
|
||||
reset(): void {
|
||||
this.heldSince.clear();
|
||||
this.fired.clear();
|
||||
}
|
||||
|
||||
private holdMsFor(spec: CommandSpec): number {
|
||||
return spec.holdMs === -1 ? this.palmHoldMs : (spec.holdMs ?? 0);
|
||||
}
|
||||
|
||||
/**
|
||||
* Feed the set of command-gestures currently shown (across all hands).
|
||||
* @returns the commands that fired on this frame (usually empty).
|
||||
*/
|
||||
update(gestures: Set<string>, nowMs: number): CommandName[] {
|
||||
// Forget gestures no longer held, so they can re-fire on the next entry.
|
||||
for (const g of [...this.heldSince.keys()]) {
|
||||
if (!gestures.has(g)) {
|
||||
this.heldSince.delete(g);
|
||||
this.fired.delete(g);
|
||||
}
|
||||
}
|
||||
|
||||
const fired: CommandName[] = [];
|
||||
for (const g of gestures) {
|
||||
const spec = GESTURE_COMMANDS[g];
|
||||
if (!spec) continue;
|
||||
|
||||
const since = this.heldSince.get(g) ?? nowMs;
|
||||
if (!this.heldSince.has(g)) this.heldSince.set(g, since);
|
||||
if (this.fired.has(g)) continue;
|
||||
|
||||
if (nowMs - since >= this.holdMsFor(spec)) {
|
||||
fired.push(spec.name);
|
||||
this.fired.add(g);
|
||||
}
|
||||
}
|
||||
return fired;
|
||||
}
|
||||
|
||||
/** 0–1 charge of the held halt-all gesture (1 once fired, 0 when released). */
|
||||
haltProgress(nowMs: number): number {
|
||||
const since = this.heldSince.get('Open_Palm');
|
||||
if (since === undefined) return 0;
|
||||
if (this.fired.has('Open_Palm')) return 1;
|
||||
return Math.min(1, (nowMs - since) / this.palmHoldMs);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,78 @@
|
||||
// MediaPipe hand landmark indices and the bone connections between them.
|
||||
// See: https://developers.google.com/mediapipe/solutions/vision/hand_landmarker
|
||||
//
|
||||
// 21 landmarks per hand, each normalized to [0,1] in image space.
|
||||
|
||||
export const LANDMARK = {
|
||||
WRIST: 0,
|
||||
THUMB_CMC: 1,
|
||||
THUMB_MCP: 2,
|
||||
THUMB_IP: 3,
|
||||
THUMB_TIP: 4,
|
||||
INDEX_MCP: 5,
|
||||
INDEX_PIP: 6,
|
||||
INDEX_DIP: 7,
|
||||
INDEX_TIP: 8,
|
||||
MIDDLE_MCP: 9,
|
||||
MIDDLE_PIP: 10,
|
||||
MIDDLE_DIP: 11,
|
||||
MIDDLE_TIP: 12,
|
||||
RING_MCP: 13,
|
||||
RING_PIP: 14,
|
||||
RING_DIP: 15,
|
||||
RING_TIP: 16,
|
||||
PINKY_MCP: 17,
|
||||
PINKY_PIP: 18,
|
||||
PINKY_DIP: 19,
|
||||
PINKY_TIP: 20,
|
||||
} as const;
|
||||
|
||||
/** Pairs of landmark indices that form the hand skeleton, for overlay drawing. */
|
||||
export const HAND_CONNECTIONS: ReadonlyArray<readonly [number, number]> = [
|
||||
// Thumb
|
||||
[0, 1],
|
||||
[1, 2],
|
||||
[2, 3],
|
||||
[3, 4],
|
||||
// Index
|
||||
[0, 5],
|
||||
[5, 6],
|
||||
[6, 7],
|
||||
[7, 8],
|
||||
// Middle
|
||||
[5, 9],
|
||||
[9, 10],
|
||||
[10, 11],
|
||||
[11, 12],
|
||||
// Ring
|
||||
[9, 13],
|
||||
[13, 14],
|
||||
[14, 15],
|
||||
[15, 16],
|
||||
// Pinky
|
||||
[13, 17],
|
||||
[17, 18],
|
||||
[18, 19],
|
||||
[19, 20],
|
||||
// Palm base
|
||||
[0, 17],
|
||||
];
|
||||
|
||||
export interface NormalizedLandmark {
|
||||
x: number;
|
||||
y: number;
|
||||
z: number;
|
||||
visibility?: number;
|
||||
}
|
||||
|
||||
/** Euclidean distance between two normalized landmarks (x/y plane). */
|
||||
export function dist2d(a: NormalizedLandmark, b: NormalizedLandmark): number {
|
||||
const dx = a.x - b.x;
|
||||
const dy = a.y - b.y;
|
||||
return Math.hypot(dx, dy);
|
||||
}
|
||||
|
||||
/** Midpoint of two normalized landmarks (x/y plane). */
|
||||
export function midpoint(a: NormalizedLandmark, b: NormalizedLandmark): { x: number; y: number } {
|
||||
return { x: (a.x + b.x) / 2, y: (a.y + b.y) / 2 };
|
||||
}
|
||||
@@ -0,0 +1,67 @@
|
||||
// Pinch detection from hand landmarks.
|
||||
//
|
||||
// Distance between thumb tip (4) and index tip (8), normalized by hand size
|
||||
// (wrist 0 → middle-finger MCP 9) so the threshold is robust to how close the
|
||||
// hand is to the camera. Hysteresis + N-frame persistence keep the grab/release
|
||||
// edge from flickering — critical for not "dropping" a tab mid-drag.
|
||||
|
||||
import { LANDMARK, dist2d, type NormalizedLandmark } from './landmarks.ts';
|
||||
|
||||
/**
|
||||
* Thumb-tip→index-tip distance as a fraction of hand size. Smaller = more
|
||||
* pinched. Roughly in [0, ~1.5]; ~0.35 is a firm pinch, ~0.5+ is open.
|
||||
*/
|
||||
export function pinchDistance(landmarks: NormalizedLandmark[]): number {
|
||||
const thumb = landmarks[LANDMARK.THUMB_TIP];
|
||||
const index = landmarks[LANDMARK.INDEX_TIP];
|
||||
const wrist = landmarks[LANDMARK.WRIST];
|
||||
const middleMcp = landmarks[LANDMARK.MIDDLE_MCP];
|
||||
const handSize = dist2d(wrist, middleMcp) || 1e-6;
|
||||
return dist2d(thumb, index) / handSize;
|
||||
}
|
||||
|
||||
/**
|
||||
* Tracks pinch state with two thresholds (hysteresis) and a persistence count.
|
||||
* Enter a pinch below `onThreshold`; leave it only above `offThreshold`
|
||||
* (offThreshold > onThreshold). A flip must hold for `persistFrames` frames
|
||||
* before it commits, rejecting single-frame noise.
|
||||
*/
|
||||
export class PinchDetector {
|
||||
private pinching = false;
|
||||
private pendingFrames = 0;
|
||||
|
||||
constructor(
|
||||
private onThreshold = 0.35,
|
||||
private offThreshold = 0.5,
|
||||
private persistFrames = 2
|
||||
) {}
|
||||
|
||||
reset(): void {
|
||||
this.pinching = false;
|
||||
this.pendingFrames = 0;
|
||||
}
|
||||
|
||||
get isPinching(): boolean {
|
||||
return this.pinching;
|
||||
}
|
||||
|
||||
/** Feed one frame's distance. Returns true if the committed state CHANGED. */
|
||||
update(distance: number): boolean {
|
||||
const target = this.pinching
|
||||
? distance < this.offThreshold // stay pinched until the hand opens wide
|
||||
: distance < this.onThreshold; // start pinching once fingers close
|
||||
|
||||
if (target === this.pinching) {
|
||||
this.pendingFrames = 0;
|
||||
return false;
|
||||
}
|
||||
|
||||
this.pendingFrames += 1;
|
||||
if (this.pendingFrames >= this.persistFrames) {
|
||||
this.pinching = target;
|
||||
this.pendingFrames = 0;
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,80 @@
|
||||
// Shared types for the gesture input layer.
|
||||
//
|
||||
// Phase 0/1 scope: only `status` and `results` (debug) events are emitted yet.
|
||||
// The semantic events (hover/grab/drag/drop/command) are declared here so the
|
||||
// public API shape is stable, but they are wired in later phases.
|
||||
|
||||
import type { GestureRecognizerResult } from '@mediapipe/tasks-vision';
|
||||
|
||||
export interface GestureControllerOptions {
|
||||
/** The <video> element the camera stream is attached to. */
|
||||
video: HTMLVideoElement;
|
||||
/** Element whose bounding rect normalized coords are mapped against. Defaults to video. (Used from Phase 2.) */
|
||||
surface?: HTMLElement;
|
||||
/** Number of hands to track. v1 = 1. */
|
||||
numHands?: number;
|
||||
/** Pinch hysteresis thresholds (fractions of hand-size). Used from Phase 2. */
|
||||
pinchOn?: number;
|
||||
pinchOff?: number;
|
||||
/** One-Euro cursor smoothing. Lower minCutoff = smoother/laggier when still;
|
||||
* higher beta = less lag during fast moves. Used from Phase 2. */
|
||||
minCutoff?: number;
|
||||
beta?: number;
|
||||
/** How long Open_Palm must be held to fire halt-all. Used from Phase 4. */
|
||||
palmHoldMs?: number;
|
||||
/** Specific camera to open (from enumerateDevices). Empty = default facingMode "user". */
|
||||
deviceId?: string;
|
||||
/** MediaPipe detection/tracking confidence. */
|
||||
minDetectionConfidence?: number;
|
||||
minTrackingConfidence?: number;
|
||||
/** CDN base used to load the wasm fileset + .task model. */
|
||||
wasmBase?: string;
|
||||
modelUrl?: string;
|
||||
}
|
||||
|
||||
export type CommandName = 'halt-all' | 'approve' | 'new-session';
|
||||
|
||||
/** Per-hand state for the current frame. */
|
||||
export interface HandState {
|
||||
/** "Left" / "Right" as reported by MediaPipe (image-space). Used to key filters. */
|
||||
handedness: string;
|
||||
/** Smoothed cursor in raw (unmirrored) normalized [0,1] coords; consumers mirror X. */
|
||||
cursor: { x: number; y: number };
|
||||
/** Thumb/index distance as a fraction of hand size. */
|
||||
pinchDist: number;
|
||||
/** Whether this hand is currently pinching (after hysteresis). */
|
||||
pinching: boolean;
|
||||
/** Top gesture category for this hand, if any. */
|
||||
gesture: string | null;
|
||||
}
|
||||
|
||||
/** A pointer sample for one hand, in surface pixel coords (origin = surface
|
||||
* top-left, X already mirrored to match the displayed video). */
|
||||
export interface HandPointer {
|
||||
hand: string;
|
||||
x: number;
|
||||
y: number;
|
||||
}
|
||||
|
||||
/** Payloads emitted per event name. */
|
||||
export interface GestureEventMap {
|
||||
/** Pinch just closed — start of a drag. */
|
||||
grab: HandPointer;
|
||||
/** Cursor moved while pinched — emitted every frame during a drag. */
|
||||
drag: HandPointer;
|
||||
/** Pinch released (or the hand vanished mid-pinch) — end of a drag. */
|
||||
drop: HandPointer;
|
||||
command: { name: CommandName };
|
||||
status: {
|
||||
fps: number;
|
||||
/** One entry per detected hand (0–`numHands`). */
|
||||
hands: HandState[];
|
||||
/** 0–1 charge of the held Open_Palm halt-all gesture (Phase 4). */
|
||||
haltProgress: number;
|
||||
};
|
||||
/** Debug-only: the raw recognizer result for the current frame (drives the overlay). */
|
||||
results: { result: GestureRecognizerResult; timestampMs: number };
|
||||
}
|
||||
|
||||
export type GestureEventName = keyof GestureEventMap;
|
||||
export type GestureEventHandler<K extends GestureEventName> = (payload: GestureEventMap[K]) => void;
|
||||
@@ -0,0 +1,188 @@
|
||||
// Phase 3 demo wiring.
|
||||
//
|
||||
// - Start button (camera requires a user gesture) + live camera picker.
|
||||
// - Mirrored video preview + debug overlay (skeleton + per-hand cursors).
|
||||
// - Live HUD: fps / hands / pinch distance / gesture.
|
||||
// - Tab board: pinch-drag session tabs between Screen columns.
|
||||
|
||||
import { GestureController } from './gesture/GestureController.ts';
|
||||
import { Overlay, type CursorMark } from './demo/overlay.ts';
|
||||
import { TabsBoard } from './demo/tabs.ts';
|
||||
import type { HandState } from './gesture/types.ts';
|
||||
|
||||
// Cyan for the left hand, violet for the right; green takes over while pinching.
|
||||
const handColor = (handedness: string): string => (handedness === 'Right' ? '#a78bfa' : '#38bdf8');
|
||||
|
||||
const video = document.getElementById('cam') as HTMLVideoElement;
|
||||
const canvas = document.getElementById('overlay') as HTMLCanvasElement;
|
||||
const stage = document.getElementById('stage') as HTMLDivElement;
|
||||
const boardEl = document.getElementById('board') as HTMLDivElement;
|
||||
const startBtn = document.getElementById('start') as HTMLButtonElement;
|
||||
const stopBtn = document.getElementById('stop') as HTMLButtonElement;
|
||||
const fullscreenBtn = document.getElementById('fullscreen') as HTMLButtonElement;
|
||||
const cameraSel = document.getElementById('camera') as HTMLSelectElement;
|
||||
const fpsEl = document.getElementById('fps') as HTMLSpanElement;
|
||||
const handEl = document.getElementById('hand') as HTMLSpanElement;
|
||||
const pinchEl = document.getElementById('pinch') as HTMLSpanElement;
|
||||
const gestureEl = document.getElementById('gesture') as HTMLSpanElement;
|
||||
const statusEl = document.getElementById('status-msg') as HTMLParagraphElement;
|
||||
|
||||
const overlay = new Overlay(canvas, video);
|
||||
// Coords map against the stage rect (the board overlays it exactly).
|
||||
const gc = new GestureController({ video, surface: stage, numHands: 2 });
|
||||
|
||||
const board = new TabsBoard(boardEl, (tabId, columnId) => {
|
||||
statusEl.textContent = columnId
|
||||
? `Moved “${tabId}” → ${columnId}`
|
||||
: `“${tabId}” dropped outside a column — returned.`;
|
||||
});
|
||||
|
||||
// The board drives off discrete grab/drag/drop; hover highlight off `status`.
|
||||
gc.on('grab', ({ hand, x, y }) => board.grab(hand, x, y));
|
||||
gc.on('drag', ({ hand, x, y }) => board.drag(hand, x, y));
|
||||
gc.on('drop', ({ hand, x, y }) => board.drop(hand, x, y));
|
||||
|
||||
// Discrete gesture commands (halt-all / approve / new-session) are intentionally
|
||||
// not wired up here — this build is pinch-drag only. The controller still emits
|
||||
// `command`/`haltProgress`, but nothing consumes them, so an open palm, thumb,
|
||||
// or victory sign does nothing.
|
||||
|
||||
// Cached from `status` so the `results` handler draws the same frame's cursors.
|
||||
let cursors: CursorMark[] = [];
|
||||
let started = false;
|
||||
|
||||
gc.on('results', ({ result }) => {
|
||||
overlay.draw(result, cursors);
|
||||
});
|
||||
|
||||
gc.on('status', ({ fps, hands }) => {
|
||||
cursors = hands.map((h) => ({
|
||||
x: h.cursor.x,
|
||||
y: h.cursor.y,
|
||||
color: handColor(h.handedness),
|
||||
pinching: h.pinching,
|
||||
}));
|
||||
|
||||
// Hover highlights from the full per-frame snapshot (surface px, X mirrored).
|
||||
const rect = stage.getBoundingClientRect();
|
||||
board.hover(
|
||||
hands.map((h) => ({
|
||||
x: (1 - h.cursor.x) * rect.width,
|
||||
y: h.cursor.y * rect.height,
|
||||
pinching: h.pinching,
|
||||
}))
|
||||
);
|
||||
|
||||
fpsEl.textContent = String(fps);
|
||||
fpsEl.style.color = fps >= 25 ? '#4ade80' : fps > 0 ? '#fbbf24' : '#f87171';
|
||||
|
||||
const anyPinching = hands.some((h) => h.pinching);
|
||||
handEl.textContent = hands.length ? hands.map((h) => h.handedness).join(' + ') : 'no';
|
||||
handEl.style.color = hands.length ? '#4ade80' : '#94a3b8';
|
||||
pinchEl.textContent = hands.length ? hands.map(pinchLabel).join(' ') : '—';
|
||||
pinchEl.style.color = anyPinching ? '#4ade80' : '#94a3b8';
|
||||
gestureEl.textContent =
|
||||
hands
|
||||
.filter((h) => h.gesture)
|
||||
.map((h) => h.gesture)
|
||||
.join(', ') || '—';
|
||||
});
|
||||
|
||||
/** e.g. "L 0.34●" — first letter of handedness, distance, dot when pinching. */
|
||||
function pinchLabel(h: HandState): string {
|
||||
return `${h.handedness[0]} ${h.pinchDist.toFixed(2)}${h.pinching ? '●' : ''}`;
|
||||
}
|
||||
|
||||
startBtn.addEventListener('click', async () => {
|
||||
startBtn.disabled = true;
|
||||
statusEl.textContent = 'Requesting camera + loading model…';
|
||||
try {
|
||||
await gc.start();
|
||||
started = true;
|
||||
statusEl.textContent = 'Running. Pinch-drag tabs between Screens.';
|
||||
stopBtn.disabled = false;
|
||||
await populateCameras();
|
||||
} catch (err) {
|
||||
console.error(err);
|
||||
statusEl.textContent = `Failed to start: ${(err as Error).message}`;
|
||||
startBtn.disabled = false;
|
||||
}
|
||||
});
|
||||
|
||||
stopBtn.addEventListener('click', () => {
|
||||
gc.stop();
|
||||
started = false;
|
||||
overlay.clear();
|
||||
board.hover([]);
|
||||
cursors = [];
|
||||
statusEl.textContent = 'Stopped.';
|
||||
startBtn.disabled = false;
|
||||
stopBtn.disabled = true;
|
||||
cameraSel.disabled = true;
|
||||
fpsEl.textContent = '0';
|
||||
handEl.textContent = 'no';
|
||||
pinchEl.textContent = '—';
|
||||
gestureEl.textContent = '—';
|
||||
});
|
||||
|
||||
// Switch cameras live. On macOS the iPhone (Continuity Camera) shows up as
|
||||
// "iPhone Camera" plus a separate "Desk View Camera" (the ultra-wide lens).
|
||||
cameraSel.addEventListener('change', async () => {
|
||||
statusEl.textContent = `Switching to ${cameraSel.selectedOptions[0]?.text}…`;
|
||||
try {
|
||||
await gc.useCamera(cameraSel.value);
|
||||
statusEl.textContent = 'Running.';
|
||||
// Activating the iPhone can surface its Desk View device — re-check.
|
||||
await populateCameras();
|
||||
} catch (err) {
|
||||
console.error(err);
|
||||
statusEl.textContent = `Couldn't switch camera: ${(err as Error).message}`;
|
||||
}
|
||||
});
|
||||
|
||||
// Cameras come and go (iPhone mounted/unmounted, Desk View appearing). Keep
|
||||
// the dropdown in sync whenever the device set changes.
|
||||
navigator.mediaDevices?.addEventListener('devicechange', () => {
|
||||
if (started) void populateCameras();
|
||||
});
|
||||
|
||||
// Fullscreen the stage so the board (and grab targets) fill the display.
|
||||
// Standard API with a webkit fallback for Safari.
|
||||
type WebkitEl = HTMLElement & { webkitRequestFullscreen?: () => Promise<void> };
|
||||
type WebkitDoc = Document & {
|
||||
webkitFullscreenElement?: Element | null;
|
||||
webkitExitFullscreen?: () => Promise<void>;
|
||||
};
|
||||
|
||||
function fullscreenElement(): Element | null {
|
||||
return document.fullscreenElement ?? (document as WebkitDoc).webkitFullscreenElement ?? null;
|
||||
}
|
||||
|
||||
fullscreenBtn.addEventListener('click', () => {
|
||||
if (fullscreenElement()) {
|
||||
(document.exitFullscreen ?? (document as WebkitDoc).webkitExitFullscreen)?.call(document);
|
||||
} else {
|
||||
const el = stage as WebkitEl;
|
||||
(el.requestFullscreen ?? el.webkitRequestFullscreen)?.call(el);
|
||||
}
|
||||
});
|
||||
|
||||
function syncFullscreenLabel(): void {
|
||||
fullscreenBtn.textContent = fullscreenElement() ? '⤢ Exit fullscreen' : '⛶ Fullscreen';
|
||||
}
|
||||
document.addEventListener('fullscreenchange', syncFullscreenLabel);
|
||||
document.addEventListener('webkitfullscreenchange', syncFullscreenLabel);
|
||||
|
||||
/** Fill the camera dropdown; labels appear only after camera permission. */
|
||||
async function populateCameras(): Promise<void> {
|
||||
const cams = await gc.listCameras();
|
||||
cameraSel.innerHTML = '';
|
||||
cams.forEach((cam, i) => {
|
||||
const opt = document.createElement('option');
|
||||
opt.value = cam.deviceId;
|
||||
opt.text = cam.label || `Camera ${i + 1}`;
|
||||
if (cam.deviceId === gc.deviceId) opt.selected = true;
|
||||
cameraSel.append(opt);
|
||||
});
|
||||
cameraSel.disabled = cams.length < 2;
|
||||
}
|
||||
@@ -0,0 +1,22 @@
|
||||
{
|
||||
"compilerOptions": {
|
||||
"target": "ES2020",
|
||||
"useDefineForClassFields": true,
|
||||
"module": "ESNext",
|
||||
"lib": ["ES2020", "DOM", "DOM.Iterable"],
|
||||
"skipLibCheck": true,
|
||||
|
||||
"moduleResolution": "bundler",
|
||||
"allowImportingTsExtensions": true,
|
||||
"resolveJsonModule": true,
|
||||
"isolatedModules": true,
|
||||
"moduleDetection": "force",
|
||||
"noEmit": true,
|
||||
|
||||
"strict": true,
|
||||
"noUnusedLocals": true,
|
||||
"noUnusedParameters": true,
|
||||
"noFallthroughCasesInSwitch": true
|
||||
},
|
||||
"include": ["src"]
|
||||
}
|
||||
@@ -0,0 +1,12 @@
|
||||
import { defineConfig } from 'vite';
|
||||
|
||||
// getUserMedia requires a secure context. http://localhost counts as secure,
|
||||
// so the dev server below is fine. If you serve to another device, use https.
|
||||
export default defineConfig({
|
||||
root: '.',
|
||||
server: {
|
||||
host: 'localhost',
|
||||
port: 5173,
|
||||
open: true,
|
||||
},
|
||||
});
|
||||
@@ -0,0 +1,52 @@
|
||||
#!/usr/bin/env node
|
||||
/**
|
||||
* @fileoverview Build the opt-in gesture-overlay bundle from its vendored source
|
||||
* in `packages/gesture-control/` into the web bundle Codeman actually serves,
|
||||
* `src/web/public/gesture/gesture-codeman.js`.
|
||||
*
|
||||
* The source lives in this repo (workspace package `codeman-gesture-control`,
|
||||
* was the standalone `Ark0N/codeman-gesture-control` repo before it was vendored
|
||||
* in). `src/codeman/entry.ts` is the Codeman *consumer* entry — it imports the
|
||||
* transport-agnostic gesture core (`src/gesture/*`) and maps grab/drag/drop onto
|
||||
* Codeman's real session tabs + toolbar buttons. esbuild bundles it (MediaPipe
|
||||
* tasks-vision JS included) into a single ESM file; the MediaPipe wasm + model
|
||||
* are loaded at runtime from same-origin `/gesture/wasm` + `/gesture/*.task`
|
||||
* (fetched separately by scripts/fetch-gesture-assets.mjs), NOT bundled here.
|
||||
*
|
||||
* Run it after editing anything under packages/gesture-control/src/ and commit
|
||||
* the regenerated bundle (the committed copy is what `npm run dev` / tsx serves,
|
||||
* since the web UI ships as plain JS with no bundler). `npm run build` also runs
|
||||
* this so a production build always reflects the current source.
|
||||
*
|
||||
* Usage: node scripts/build-gesture-bundle.mjs [--out <path>]
|
||||
* --out output file (default src/web/public/gesture/gesture-codeman.js)
|
||||
*
|
||||
* NOT minified — matches the historical bundle and keeps it debuggable; the
|
||||
* build's compress step gzips/brotlis it for production anyway.
|
||||
*/
|
||||
import { build } from 'esbuild';
|
||||
import { fileURLToPath } from 'node:url';
|
||||
import { join, dirname, isAbsolute } from 'node:path';
|
||||
|
||||
const ROOT = join(dirname(fileURLToPath(import.meta.url)), '..');
|
||||
const ENTRY = join(ROOT, 'packages/gesture-control/src/codeman/entry.ts');
|
||||
const DEFAULT_OUT = join(ROOT, 'src/web/public/gesture/gesture-codeman.js');
|
||||
|
||||
const outArg = process.argv[process.argv.indexOf('--out') + 1];
|
||||
const outfile =
|
||||
process.argv.includes('--out') && outArg
|
||||
? isAbsolute(outArg)
|
||||
? outArg
|
||||
: join(process.cwd(), outArg)
|
||||
: DEFAULT_OUT;
|
||||
|
||||
await build({
|
||||
entryPoints: [ENTRY],
|
||||
bundle: true,
|
||||
format: 'esm',
|
||||
target: 'es2020',
|
||||
outfile,
|
||||
logLevel: 'info',
|
||||
});
|
||||
|
||||
console.log(`[gesture] bundle built → ${outfile}`);
|
||||
@@ -35,6 +35,9 @@ run('prepare dirs', 'mkdir -p dist/web dist/templates dist/web/public/vendor');
|
||||
// Fetch the opt-in gesture overlay's MediaPipe wasm + model into src/ (idempotent,
|
||||
// non-fatal, kept out of git) so the copy below carries them into dist/.
|
||||
run('gesture assets', 'node scripts/fetch-gesture-assets.mjs');
|
||||
// Rebuild the gesture overlay bundle from its vendored source (packages/gesture-control)
|
||||
// into src/web/public/gesture/gesture-codeman.js, so prod always reflects current source.
|
||||
run('gesture bundle', 'node scripts/build-gesture-bundle.mjs');
|
||||
run('copy web assets', 'cp -r src/web/public dist/web/');
|
||||
run('copy template', 'cp src/templates/case-template.md dist/templates/');
|
||||
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
Reference in New Issue
Block a user