code-coordinator 0.5.46__py3-none-any.whl

coord/dashboard/webapp/package.json

@@ -0,0 +1,63 @@
+{
+  "name": "coord-webapp",
+  "private": true,
+  "version": "0.0.1",
+  "type": "module",
+  "scripts": {
+    "dev": "vite",
+    "build": "tsc && vite build",
+    "preview": "vite preview",
+    "typecheck": "tsc --noEmit",
+    "codegen": "cd ../../.. && .venv/bin/python scripts/codegen.py",
+    "codegen:check": "cd ../../.. && .venv/bin/python scripts/codegen.py --check",
+    "lint": "eslint src --report-unused-disable-directives --max-warnings 0",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:e2e": "playwright test",
+    "test:e2e:ui": "playwright test --ui",
+    "test:acceptance": "playwright test --config=playwright.acceptance.config.ts"
+  },
+  "dependencies": {
+    "@radix-ui/react-dialog": "^1.1.23",
+    "@radix-ui/react-dropdown-menu": "^2.1.24",
+    "@radix-ui/react-slot": "^1.3.3",
+    "@radix-ui/react-tabs": "^1.1.21",
+    "@radix-ui/react-toast": "^1.2.23",
+    "@radix-ui/react-tooltip": "^1.2.16",
+    "@tanstack/react-query": "^5.62.2",
+    "@xterm/addon-fit": "^0.11.0",
+    "@xterm/xterm": "^6.0.0",
+    "class-variance-authority": "^0.7.0",
+    "clsx": "^2.1.1",
+    "lucide-react": "^0.462.0",
+    "react": "^18.3.1",
+    "react-dom": "^18.3.1",
+    "react-router-dom": "^6.28.0",
+    "tailwind-merge": "^2.5.5",
+    "tailwindcss-animate": "^1.0.7"
+  },
+  "devDependencies": {
+    "@playwright/test": "^1.61.1",
+    "@testing-library/jest-dom": "^6.6.3",
+    "@testing-library/react": "^16.1.0",
+    "@testing-library/user-event": "^14.5.2",
+    "@types/node": "^26.1.2",
+    "@types/react": "^18.3.12",
+    "@types/react-dom": "^18.3.1",
+    "@typescript-eslint/eslint-plugin": "^8.14.0",
+    "@typescript-eslint/parser": "^8.14.0",
+    "@vitejs/plugin-react": "^4.3.3",
+    "autoprefixer": "^10.4.20",
+    "eslint": "^9.14.0",
+    "eslint-plugin-react-hooks": "^5.0.0",
+    "eslint-plugin-react-refresh": "^0.4.14",
+    "jsdom": "^25.0.1",
+    "postcss": "^8.4.47",
+    "tailwindcss": "^3.4.14",
+    "typescript": "^5.6.3",
+    "vite": "^5.4.10",
+    "vite-plugin-pwa": "^0.21.1",
+    "vitest": "^2.1.8",
+    "workbox-build": "^7.3.0"
+  }
+}

coord/dashboard/webapp/playwright.acceptance.config.ts

@@ -0,0 +1,166 @@
+/**
+ * Playwright config for the SEALED oracle-loop acceptance suite (#1540),
+ * as opposed to `playwright.config.ts` (the `e2e/` smoke net — untouched,
+ * keeps running via `npm run test:e2e`).
+ *
+ * Why a sibling config rather than editing `playwright.config.ts` in place
+ * (docs/ORACLE_LOOP.md, #1552's "wiring failure, not a test failure" bug,
+ * arriving here in Playwright-shaped form):
+ *
+ * 1. `playwright.config.ts`'s `testDir: './e2e'` is invisible to anything
+ *    under repo-root `tests/acceptance/ms-NN/` — a path filter pointing
+ *    outside `testDir` matches zero files and Playwright exits 0 with 0
+ *    tests. That is a silent, confidently-wrong green, not a red. This
+ *    config's `testDir` points at the sealed tree instead so a slice
+ *    actually gets discovered.
+ * 2. The acceptance run must select a machine-readable reporter, not
+ *    inherit `e2e`'s CI-conditional `'github'`. In practice the
+ *    `web-playwright` driver (#1539, coord/acceptance_drivers.py
+ *    `_run_web_playwright`) always appends `--reporter=json` on the CLI,
+ *    which overrides whatever `reporter:` this file declares — but this
+ *    file still picks an explicit, non-CI-conditional default (`'list'`)
+ *    so a human running it directly (outside the driver) gets readable
+ *    output instead of silently inheriting a `CI` env var's default.
+ *
+ * `run:` (acceptance.drivers.claude-coordinator.routes, coordinator.yml):
+ *   cd coord/dashboard/webapp && npm run test:acceptance -- {ms}
+ * `{ms}` (e.g. "ms-40") is substituted by `render_run_command` and passed as
+ * Playwright's positional test-file filter — it matches by substring against
+ * each spec file's resolved path, so `tests/acceptance/ms-40/foo.spec.ts`
+ * matches the filter `ms-40` without needing an exact relative path. This
+ * config also reads that same `ms-NN` token back out of `process.argv` (see
+ * `resolveFixturePath` below) to decide what to seed the webServer with.
+ *
+ * `entrypoint:` — deliberately NOT set on this route (#1552). Playwright
+ * discovers specs by walking `testDir`, exactly like `cli-pytest`'s
+ * `pytest tests/acceptance/{ms}` — there is no crate-root-style file that
+ * must `include!`/import each slice before it becomes reachable, so there is
+ * nothing to fold into `AcceptanceConfig.sealed_paths()`.
+ *
+ * `webServer` (#1818): boots a REAL `coord web --fixture <file> --dist dist`
+ * process (`coord/dashboard/fixture.py`, #1538) instead of the Vite dev
+ * server — deterministic reads with no daemon, no live fleet, no network,
+ * mirroring what `e2e/fixtureServer.ts` already does for
+ * `live-update-fixture.spec.ts`. `npm run build` runs first because
+ * `--dist` needs a production bundle on disk; both steps are chained into
+ * one `command` string so nothing outside this file has to remember to
+ * build before testing. `coord` must be resolvable on `$PATH` — true by
+ * construction here: this suite is only ever invoked by the `web-playwright`
+ * acceptance driver, which is itself `coord acceptance run`/`record`, so the
+ * `coord` CLI is always already installed on whatever machine reaches this
+ * config.
+ *
+ * Seeding convention for a slice (#1818): a milestone directory may declare
+ * `tests/acceptance/ms-NN/fixtures/<name>.json` — a `coord/dashboard/
+ * fixture.py`-shaped fixture, sealed alongside that milestone's
+ * `mocks/*.html`, so a slice's seed is part of the tree the test-author
+ * owns (see `coord.test_author.TEST_AUTHOR_SYSTEM_PROMPT`, which tells the
+ * next web test-author to write one of these instead of inventing an inline
+ * `page.route()` payload). Exactly one `*.json` file is expected per `ms-NN`
+ * directory; `resolveFixturePath` raises at config-load time if it finds
+ * more than one, rather than silently picking one and hiding the ambiguity.
+ * A milestone with no `fixtures/` directory falls back to the repo-wide
+ * `tests/fixtures/board-pipeline-basic.json` default (the same fixture
+ * `e2e/fixtureServer.ts` uses) — harmless for a slice that seeds itself
+ * another way.
+ *
+ * ms-51 (#1544's proving rig) is deliberately left on `page.route()` — see
+ * that slice's own header comment and #1818's "recommend leaving ms-51
+ * alone" — so it falls back to the default fixture above and ignores
+ * whatever it serves; ms-52 onward is where a slice is expected to declare
+ * its own `fixtures/*.json` and drop `page.route()` entirely. Known hazard
+ * ms-51 no longer inherits from a dev server (worth stating precisely,
+ * since a stale hazard note is worse than none): React 18 StrictMode's
+ * double-invoked effects were a *Vite dev mode* quirk, not a production
+ * bundle one, so a fixture-backed slice authored from here on doesn't need
+ * to write around it — but assertions should still prefer eventual state
+ * (`expect(...).toHaveText(...)`, `waitFor`) over exact effect/call counts,
+ * which is good practice regardless of backend.
+ */
+
+import { defineConfig, devices } from '@playwright/test'
+import fs from 'node:fs'
+import path from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+const here = path.dirname(fileURLToPath(import.meta.url))
+const REPO_ROOT = path.resolve(here, '../../..')
+const ACCEPTANCE_DIR = path.resolve(here, '../../../tests/acceptance')
+const DIST_DIR = path.join(here, 'dist')
+const DEFAULT_FIXTURE = path.join(REPO_ROOT, 'tests/fixtures/board-pipeline-basic.json')
+
+/**
+ * Resolve which fixture JSON seeds `coord web --fixture` for this run.
+ *
+ * The driver's `run:` command passes the target milestone as a positional
+ * filter (`npm run test:acceptance -- ms-51`), and Playwright forwards CLI
+ * args through verbatim, so `process.argv` already carries the `ms-NN`
+ * token this config needs — no second side-channel required. Falls back to
+ * `DEFAULT_FIXTURE` when no `ms-NN` arg is present (a bare `npm run
+ * test:acceptance` running the whole tree) or the matched milestone has no
+ * `fixtures/` directory of its own.
+ */
+function resolveFixturePath(): string {
+  const msArg = process.argv.find((a) => /^ms-\d+$/.test(a))
+  if (msArg) {
+    const fixturesDir = path.join(ACCEPTANCE_DIR, msArg, 'fixtures')
+    if (fs.existsSync(fixturesDir)) {
+      const files = fs
+        .readdirSync(fixturesDir)
+        .filter((f) => f.endsWith('.json'))
+        .sort()
+      if (files.length > 1) {
+        throw new Error(
+          `${fixturesDir} declares ${files.length} fixture files ` +
+            `(${files.join(', ')}) — the acceptance webServer expects at ` +
+            'most one per ms-NN directory. Split into separate ms-NN ' +
+            'milestones instead of disambiguating fixtures within one.',
+        )
+      }
+      if (files.length === 1) return path.join(fixturesDir, files[0])
+    }
+  }
+  return DEFAULT_FIXTURE
+}
+
+const FIXTURE_PATH = resolveFixturePath()
+
+export default defineConfig({
+  testDir: ACCEPTANCE_DIR,
+  testMatch: '**/*.spec.ts',
+
+  fullyParallel: false,
+  workers: 1,
+
+  forbidOnly: !!process.env.CI,
+  retries: process.env.CI ? 1 : 0,
+
+  // Explicit, non-CI-conditional default — see module docstring point 2.
+  // The web-playwright driver overrides this at invocation with its own
+  // `--reporter=json` CLI flag regardless.
+  reporter: 'list',
+
+  use: {
+    baseURL: 'http://localhost:5173',
+    screenshot: 'only-on-failure',
+    actionTimeout: 5_000,
+  },
+
+  projects: [
+    {
+      name: 'chromium',
+      use: { ...devices['Desktop Chrome'] },
+    },
+  ],
+
+  webServer: {
+    command:
+      `npm run build && coord web --fixture "${FIXTURE_PATH}" ` +
+      `--dist "${DIST_DIR}" --host 127.0.0.1 --port 5173`,
+    url: 'http://localhost:5173',
+    reuseExistingServer: !process.env.CI,
+    // `npm run build` (tsc && vite build) plus process boot, comfortably
+    // over the old Vite-dev-only 30s budget.
+    timeout: 90_000,
+  },
+})

coord/dashboard/webapp/playwright.config.ts

@@ -0,0 +1,93 @@
+/**
+ * Playwright E2E configuration for the coord webapp.
+ *
+ * Run: npm run test:e2e
+ *
+ * Prerequisites (one-time per machine):
+ *   npx playwright install chromium
+ *
+ * Design:
+ *  - The Vite dev server is started automatically by Playwright's
+ *    `webServer` option, so no separate `npm run dev` is needed.
+ *  - API calls (`/api/pipeline`, `/api/board`, …) are intercepted via
+ *    `page.route()` inside each test — no live Python daemon required.
+ *    This keeps the suite deterministic and fast. The one exception is
+ *    `live-update-fixture.spec.ts` (#1551), which boots a real
+ *    `coord web --fixture` process instead — see that file's header.
+ *  - Only Chromium is targeted.  Safari/Firefox variants belong in the
+ *    coord/dashboard/webapp smoke_tests capability group; gate them on a
+ *    machine with those browsers installed via coordinator.yml.
+ *
+ * Routing to capable hardware:
+ *   coordinator.yml smoke_tests.capability_rules:
+ *     - capability: browser
+ *       paths: [coord/dashboard/webapp/**]
+ *
+ * `wide` / `narrow` projects (#1551, M-W1's exit gate): distinct Playwright
+ * *projects*, not `test.use({ viewport })` overrides inside `chromium` (which
+ * is how `shell.spec.ts` and `smoke.spec.ts` already cover breakpoints) —
+ * the story calls for both breakpoints as their own reportable line items.
+ * Scoped via `testMatch` to only the two files authored for it
+ * (`deep-link.spec.ts`, `theme.spec.ts`) and excluded from `chromium` via
+ * `testIgnore` so they don't triple-run; every other spec's breakpoint
+ * coverage (if any) stays exactly where it already was, under `chromium`.
+ */
+
+import { defineConfig, devices } from '@playwright/test'
+
+const WIDE_VIEWPORT = { width: 1440, height: 900 }
+const NARROW_VIEWPORT = { width: 390, height: 844 }
+const BREAKPOINT_PROJECT_FILES = ['deep-link.spec.ts', 'theme.spec.ts']
+
+export default defineConfig({
+  testDir: './e2e',
+  testMatch: '**/*.spec.ts',
+
+  // Run tests sequentially (single file, small suite for now).
+  fullyParallel: false,
+  workers: 1,
+
+  // Fail the build on CI if a test is `.only`-locked.
+  forbidOnly: !!process.env.CI,
+
+  // One retry on CI to guard against flaky timing.
+  retries: process.env.CI ? 1 : 0,
+
+  reporter: process.env.CI ? 'github' : 'list',
+
+  use: {
+    // Base URL is the Vite dev server started by webServer below.
+    baseURL: 'http://localhost:5173',
+    // Capture a screenshot on failure.
+    screenshot: 'only-on-failure',
+    // Short action timeout — these are simple DOM assertions.
+    actionTimeout: 5_000,
+  },
+
+  projects: [
+    {
+      name: 'chromium',
+      use: { ...devices['Desktop Chrome'] },
+      testIgnore: BREAKPOINT_PROJECT_FILES.map((f) => `**/${f}`),
+    },
+    {
+      name: 'wide',
+      use: { ...devices['Desktop Chrome'], viewport: WIDE_VIEWPORT },
+      testMatch: BREAKPOINT_PROJECT_FILES,
+    },
+    {
+      name: 'narrow',
+      use: { ...devices['Desktop Chrome'], viewport: NARROW_VIEWPORT },
+      testMatch: BREAKPOINT_PROJECT_FILES,
+    },
+  ],
+
+  // Start the Vite dev server before running tests.
+  // Playwright waits for the URL to respond before dispatching tests.
+  webServer: {
+    command: 'npm run dev',
+    url: 'http://localhost:5173',
+    reuseExistingServer: !process.env.CI,
+    timeout: 30_000,
+  },
+})

coord/dashboard/webapp/postcss.config.js

@@ -0,0 +1,6 @@
+export default {
+  plugins: {
+    tailwindcss: {},
+    autoprefixer: {},
+  },
+}

coord/dashboard/webapp/public/icons/icon.svg

@@ -0,0 +1,5 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 512 512" width="512" height="512">
+  <rect width="512" height="512" rx="80" fill="#1f6feb"/>
+  <text x="256" y="358" font-family="monospace,ui-monospace" font-size="320" font-weight="bold"
+        fill="white" text-anchor="middle">C</text>
+</svg>

coord/dashboard/webapp/src/App.tsx

@@ -0,0 +1,140 @@
+import { lazy, Suspense } from 'react'
+import { BrowserRouter, Navigate, Routes, Route } from 'react-router-dom'
+import Detail from '@/components/Detail'
+import SessionDetail from '@/components/SessionDetail'
+import { ShellLayout } from '@/shell/ShellLayout'
+import { EmptyDetail } from '@/shell/EmptyDetail'
+import { paths } from '@/routes/paths'
+import { ThemeProvider } from '@/components/ui/theme-provider'
+import { Toaster } from '@/components/ui/toaster'
+
+// Lazy: xterm.js (#1068) is a sizable dependency that's only needed once a
+// user actually taps into a live session's take-over view -- code-splitting
+// it out of the main bundle keeps the Home/Detail initial load lean instead
+// of shipping the terminal renderer to everyone up front.
+const Terminal = lazy(() => import('@/components/Terminal'))
+
+// Dev-only component gallery (#1546) — renders every ui/* primitive in both
+// themes, so a human (or a Playwright acceptance slice) can see the whole
+// system at once without hunting through the app for each one. Route-guarded
+// by `import.meta.env.DEV` below so production can never navigate to it; it
+// still ends up as its own lazy chunk in `dist/` (Rollup splits on the
+// `import()` call site regardless of the guard), so vite.config.ts also
+// excludes it from the PWA precache list -- see the comment there.
+const Gallery = lazy(() => import('@/components/Gallery'))
+
+/**
+ * App root.  BrowserRouter is used here; the dashboard server serves index.html
+ * as a SPA fallback for all non-API paths so deep links work on hard reload.
+ *
+ * Route tree (#1548) — every screen the app can show gets one address:
+ *
+ *   /                                -> redirect to /pipeline (replace, so
+ *                                        it doesn't leave a dead entry back
+ *                                        button lands on)
+ *   /pipeline                        -> EmptyDetail in the detail slot
+ *   /pipeline/:repo/:issue           -> Detail (keyed on repo+issue, not
+ *                                        assignment_id -- see Detail.tsx)
+ *   /pipeline/:repo/:issue/:tab      -> Detail, tab param threaded through
+ *                                        for M-W2 to consume; round-trips
+ *                                        today without changing what renders
+ *   /sessions                        -> EmptyDetail
+ *   /sessions/:id                    -> SessionDetail
+ *   /board /machines /merge-queue
+ *   /milestones /audit /spend
+ *   /settings                        -> ComingSoon(view) -- placeholders for
+ *                                        the M-W2+ panels, addressable today
+ *                                        so a link to one isn't a 404 while
+ *                                        it's being built
+ *   *  (inside the shell)            -> RouteNotFound -- a real not-found
+ *                                        state for a genuinely unknown path,
+ *                                        rendered inside the shell (rail,
+ *                                        status bar) rather than a blank page
+ *
+ * Every route below `/pipeline` is a child of `ShellLayout`, the react-router
+ * *layout route*: the child fills the detail slot (rail + list + detail on
+ * wide, the phone app on narrow) and `ShellLayout` derives the rail selection
+ * and the list panel's content from the URL itself (`shellViewFromPath`)
+ * rather than from separately persisted state -- see `shellState.ts`'s doc
+ * comment.
+ *
+ * The `/` redirect is deliberately declared *outside* `ShellLayout`, as a
+ * sibling of it rather than one of its children. `AppShell` only mounts the
+ * detail slot -- the thing that would render a child route's `element` --
+ * when `showDetail` is true, and on narrow that's `false` until an item is
+ * selected (`detailActive`). A redirect placed under `ShellLayout` therefore
+ * silently never fires on a phone-sized cold load at `/`: `Outlet` is never
+ * mounted, so `<Navigate>`'s effect never runs, and the shell renders with no
+ * matched child at all -- exactly the "genuinely unknown route" case, so it
+ * falls through to the `*` not-found state instead of redirecting. Matching
+ * `/` *before* composing the shell sidesteps the whole class of bug: nothing
+ * about "should this redirect fire" may depend on shell layout state.
+ *
+ * `/terminal/:sessionId` stays deliberately *outside* the shell for a
+ * different reason: the PTY pane wants the whole viewport and brings its own
+ * key bar, and framing a terminal in a rail plus a status bar would cost it
+ * rows on exactly the device (a phone) where rows are scarcest.
+ */
+export default function App() {
+  return (
+    <ThemeProvider>
+      <BrowserRouter>
+        <Routes>
+          <Route path="/" element={<Navigate to={paths.pipeline()} replace />} />
+
+          <Route element={<ShellLayout />}>
+            <Route path="/pipeline" element={<EmptyDetail />} />
+            <Route path="/pipeline/:repo/:issue" element={<Detail />} />
+            <Route path="/pipeline/:repo/:issue/:tab" element={<Detail />} />
+
+            <Route path="/sessions" element={<EmptyDetail />} />
+            <Route path="/sessions/:id" element={<SessionDetail />} />
+
+            {/* Placeholders for the M-W2+ panels (#1548) -- addressable now,
+                not a 404, so a bookmark or a pasted link survives the panel
+                shipping later. The rail marks each of these 'soon' and won't
+                navigate here on a click (railItems.ts); this is what a typed
+                or pasted link to one lands on in the meantime. */}
+            <Route path="/board" element={null} />
+            <Route path="/machines" element={null} />
+            <Route path="/merge-queue" element={null} />
+            <Route path="/milestones" element={null} />
+            <Route path="/audit" element={null} />
+            <Route path="/spend" element={null} />
+            <Route path="/settings" element={null} />
+
+            {/* Genuinely unknown path under the shell -- a typo'd URL, or a
+                link to a feature that no longer exists. `ShellLayout` puts
+                `RouteNotFound` in the *list* slot for this case (there is no
+                "current view" to hand a list to); this route's own element
+                stays empty so wide doesn't show the same message twice. */}
+            <Route path="*" element={null} />
+          </Route>
+          <Route
+            path="/terminal/:sessionId"
+            element={
+              <div className="min-h-screen bg-background text-foreground">
+                <Suspense fallback={null}>
+                  <Terminal />
+                </Suspense>
+              </div>
+            }
+          />
+          {import.meta.env.DEV && (
+            <Route
+              path="/gallery"
+              element={
+                <div className="min-h-screen bg-background text-foreground">
+                  <Suspense fallback={null}>
+                    <Gallery />
+                  </Suspense>
+                </div>
+              }
+            />
+          )}
+        </Routes>
+      </BrowserRouter>
+      <Toaster />
+    </ThemeProvider>
+  )
+}