refactor(starter): simplify - one RPC function, no unused MCP route

Merge the two demo RPC functions (get-info static, list-items
query+snapshot) into a single get-state query+snapshot returning
{ cwd, node, items } in one round trip. Cuts an RPC file, a namespace
entry, a client fetch, and a test, without losing the pattern this
starter exists to demonstrate.

Also:
- Drop `cli.mcp: true` from the devframe definition - nothing in the
  starter exercised the MCP route, so it was dead surface.
- Drop the redundant `play` (duplicate of `play:single`) and `test:unit`
  (duplicate of `test`) package.json scripts.
- Rename test/rpc.test.ts -> test/get-state.test.ts to match the single
  function it now covers.

This PR was created with the help of an agent.

Author: antfubot

starter/README.md

@@ -24,7 +24,7 @@ pnpm run typecheck
 | Path | Purpose |
 |------|---------|
 | `src/devframe.ts` | The single `DevframeDefinition` every surface below consumes. |
-| `src/rpc/` | RPC function definitions (`get-info` static, `list-items` query+snapshot) and their namespace declaration. |
+| `src/rpc/` | The one RPC function (`get-state` - a query+snapshot returning runtime info and a directory listing) and its namespace declaration. |
 | `src/client/` | The vanilla-TS SPA: `index.html`, `main.ts`, `app.ts`, `styles.css`. |
 | `src/shared/base-path.ts` | The devframe's base path, shared between the node-side definition and browser-side client entries. |
 | `bin.mjs` | `createCac(devframe).parse()` - exposes `dev`, `build`, `mcp`. |

starter/e2e/app.test.ts

@@ -2,9 +2,9 @@ import process from 'node:process'
 import { expect, test } from '@playwright/test'
 
 // Exercises the single playground end to end: the vanilla-TS SPA connects
-// over the real WebSocket RPC bridge and renders the `list-items` /
-// `get-info` results for the fixed `./fixtures` directory (wired via
-// `playwright.config.ts`'s `webServer.env.DEVFRAME_E2E_CWD`).
+// over the real WebSocket RPC bridge and renders the `get-state` result for
+// the fixed `./fixtures` directory (wired via `playwright.config.ts`'s
+// `webServer.env.DEVFRAME_E2E_CWD`).
 test('connects and renders the list of items', async ({ page }) => {
   await page.goto('/')
 
@@ -18,7 +18,7 @@ test('connects and renders the list of items', async ({ page }) => {
   await expect(items.nth(1)).toContainText('file1.txt')
   await expect(items.nth(1)).toContainText('file')
 
-  // The "cwd" / "node" info line renders from the `get-info` RPC call.
+  // The "node" info line renders from the same `get-state` call.
   await expect(page.locator('.meta code').first()).toContainText(process.version)
 })
 

starter/package.json

@@ -28,12 +28,10 @@
     "dev": "node bin.mjs",
     "build": "vite build --config src/client/vite.config.ts",
     "cli:build": "node bin.mjs build --out-dir dist/static",
-    "play": "vite --config playground/single/vite.config.ts",
     "play:single": "vite --config playground/single/vite.config.ts",
     "play:hub": "vite --config playground/hub/vite.config.ts",
     "lint": "eslint",
     "test": "vitest run",
-    "test:unit": "vitest run",
     "test:e2e": "playwright test",
     "typecheck": "tsc --noEmit",
     "release": "bumpp"

starter/src/client/app.ts

@@ -1,14 +1,10 @@
 import type { DevframeScopedClientContext } from 'devframe/client'
+import type { StarterItem, StarterState } from '../rpc/functions/get-state.ts'
 import { connectDevframe } from 'devframe/client'
 
 const NAMESPACE = 'devframe-starter'
 type StarterCtx = DevframeScopedClientContext<typeof NAMESPACE>
 
-interface Item {
-  name: string
-  kind: 'dir' | 'file'
-}
-
 function h<K extends keyof HTMLElementTagNameMap>(
   tag: K,
   attrs: Partial<Record<string, string>> = {},
@@ -37,7 +33,7 @@ export interface MountOptions {
   baseURL?: string
 }
 
-/** Boot the SPA into `root`: connect to devframe, then render the list. */
+/** Boot the SPA into `root`: connect to devframe, then render its state. */
 export async function mount(root: HTMLElement, options: MountOptions = {}): Promise<void> {
   root.replaceChildren(h('div', { class: 'connecting' }, ['Connecting to devframe…']))
 
@@ -46,15 +42,20 @@ export async function mount(root: HTMLElement, options: MountOptions = {}): Prom
 
   const listCard = h('div', { class: 'card' })
   const count = h('span', { class: 'count' }, ['0'])
+  const nodeCode = h('code', {}, ['…'])
+  const cwdCode = h('code', {}, ['…'])
   const refreshBtn = h('button', { type: 'button' }, ['Refresh'])
 
   async function refresh(): Promise<void> {
     refreshBtn.disabled = true
     refreshBtn.textContent = 'Loading…'
     try {
-      const items = await ctx.rpc.call('list-items') as Item[]
-      count.textContent = String(items.length)
-      renderList(listCard, items)
+      // The one RPC round trip this SPA makes.
+      const state = await ctx.rpc.call('get-state') as StarterState
+      count.textContent = String(state.items.length)
+      nodeCode.textContent = state.node
+      cwdCode.textContent = state.cwd
+      renderList(listCard, state.items)
     }
     finally {
       refreshBtn.disabled = false
@@ -63,16 +64,14 @@ export async function mount(root: HTMLElement, options: MountOptions = {}): Prom
   }
   refreshBtn.addEventListener('click', () => void refresh())
 
-  const info = await ctx.rpc.call('get-info') as { cwd: string, node: string }
-
   root.replaceChildren(
     h('div', { class: 'app' }, [
       h('header', { class: 'nav' }, [
         h('span', { class: 'brand' }, [h('span', { class: 'dot' }), 'Devframe Starter']),
         h('span', { class: 'spacer' }),
         h('small', { class: 'meta' }, [
           'node ',
-          h('code', {}, [info.node]),
+          nodeCode,
           ' · backend ',
           h('code', {}, [ctx.base.connectionMeta.backend]),
         ]),
@@ -85,15 +84,15 @@ export async function mount(root: HTMLElement, options: MountOptions = {}): Prom
           refreshBtn,
         ]),
         listCard,
-        h('p', { class: 'meta' }, ['cwd: ', h('code', {}, [info.cwd])]),
+        h('p', { class: 'meta' }, ['cwd: ', cwdCode]),
       ]),
     ]),
   )
 
   await refresh()
 }
 
-function renderList(card: HTMLElement, items: Item[]): void {
+function renderList(card: HTMLElement, items: StarterItem[]): void {
   if (items.length === 0) {
     card.replaceChildren(h('p', { class: 'empty' }, ['Nothing in the working directory.']))
     return

starter/src/devframe.ts

@@ -33,9 +33,6 @@ export default defineDevframe({
     // developer who wants to skip the prompt for a one-off loopback-only
     // session can pass `--no-auth` per run (`devframe-starter --no-auth`)
     // rather than baking the opt-out into the definition.
-    //
-    // Serve the agent (MCP) surface over the dev server's `/__mcp` route.
-    mcp: true,
   },
   setup(ctx) {
     // A scoped context auto-namespaces every registered id with `NAMESPACE:`.

starter/src/rpc/functions/get-info.ts

@@ -2,24 +2,37 @@ import { readdir } from 'node:fs/promises'
 import process from 'node:process'
 import { defineRpcFunction } from 'devframe'
 
+export interface StarterItem {
+  name: string
+  kind: 'dir' | 'file'
+}
+
+export interface StarterState {
+  cwd: string
+  node: string
+  items: StarterItem[]
+}
+
 /**
  * A `query` RPC with `snapshot: true`: live over WebSocket in dev, and its
  * dump is baked into a static build so the SPA keeps working with no server.
- * Lists the top-level entries of the working directory.
+ * The one round trip the client makes - runtime info plus the top-level
+ * entries of the working directory.
  */
-export const listItems = defineRpcFunction({
-  name: 'list-items',
+export const getState = defineRpcFunction({
+  name: 'get-state',
   type: 'query',
   jsonSerializable: true,
   snapshot: true,
   setup: ctx => ({
-    handler: async () => {
+    handler: async (): Promise<StarterState> => {
       const cwd = process.env.DEVFRAME_E2E_CWD || ctx.cwd
       const entries = await readdir(cwd, { withFileTypes: true })
-      return entries
+      const items = entries
         .filter(e => !e.name.startsWith('.'))
         .map(e => ({ name: e.name, kind: e.isDirectory() ? 'dir' as const : 'file' as const }))
         .sort((a, b) => a.name.localeCompare(b.name))
+      return { cwd, node: process.version, items }
     },
   }),
 })

starter/src/rpc/functions/list-items.ts starter/src/rpc/functions/get-state.tsstarter/src/rpc/functions/list-items.ts renamed to starter/src/rpc/functions/get-state.ts

@@ -1,15 +1,14 @@
 import type { RpcDefinitionsToFunctionsWithNamespace } from 'devframe/rpc'
-import { getInfo } from './functions/get-info.ts'
-import { listItems } from './functions/list-items.ts'
+import { getState } from './functions/get-state.ts'
 
 export const NAMESPACE = 'devframe-starter'
 
-export const serverFunctions = [getInfo, listItems] as const
+export const serverFunctions = [getState] as const
 
 declare module 'devframe' {
   // Functions are defined with bare names and registered through a scoped
-  // context, so the registry keys are namespaced to match the runtime ids
-  // (`devframe-starter:get-info`, `devframe-starter:list-items`).
+  // context, so the registry key is namespaced to match the runtime id
+  // (`devframe-starter:get-state`).
   interface DevframeRpcServerFunctions
     extends RpcDefinitionsToFunctionsWithNamespace<typeof NAMESPACE, typeof serverFunctions> {}
 }

starter/src/rpc/index.ts

@@ -11,11 +11,11 @@ import devframe from '../src/devframe.ts'
 
 // The public `initDevframe` handler used by every hosted adapter (see
 // `@devframes/vite/single`) - a side-car WS server on a free port, no SPA
-// (`distDir: false`), so this test exercises the RPC functions over the real
-// wire without booting the CLI dev server or building the client first.
+// (`distDir: false`), so this test exercises `get-state` over the real wire
+// without booting the CLI dev server or building the client first.
 vi.stubGlobal('WebSocket', WebSocket)
 
-describe('rpc functions', () => {
+describe('get-state', () => {
   let tmpDir: string
   let instance: ReturnType<typeof initDevframe>
   let rpc: ReturnType<typeof createRpcClient<any, any>>
@@ -25,7 +25,7 @@ describe('rpc functions', () => {
     await writeFile(path.join(tmpDir, 'file1.txt'), '')
     await writeFile(path.join(tmpDir, 'file2.txt'), '')
     await mkdir(path.join(tmpDir, 'dir1'))
-    // The RPC functions fall back to this env var over `ctx.cwd` so tests
+    // `get-state` falls back to this env var over `ctx.cwd` so tests
     // control the working directory without touching the real `process.cwd()`.
     process.env.DEVFRAME_E2E_CWD = tmpDir
 
@@ -58,17 +58,16 @@ describe('rpc functions', () => {
     delete process.env.DEVFRAME_E2E_CWD
   })
 
-  it('get-info returns node version and cwd', async () => {
-    const info = await rpc.$call('devframe-starter:get-info')
-    expect(info).toEqual({ node: process.version, cwd: tmpDir })
-  })
-
-  it('list-items lists files and directories, sorted, dotfiles excluded', async () => {
-    const items = await rpc.$call('devframe-starter:list-items')
-    expect(items).toEqual([
-      { name: 'dir1', kind: 'dir' },
-      { name: 'file1.txt', kind: 'file' },
-      { name: 'file2.txt', kind: 'file' },
-    ])
+  it('returns runtime info and the working directory listing, sorted with dotfiles excluded', async () => {
+    const state = await rpc.$call('devframe-starter:get-state')
+    expect(state).toEqual({
+      node: process.version,
+      cwd: tmpDir,
+      items: [
+        { name: 'dir1', kind: 'dir' },
+        { name: 'file1.txt', kind: 'file' },
+        { name: 'file2.txt', kind: 'file' },
+      ],
+    })
   })
 })