refactor(recipes): rename openHelpers to commonRpcFunctions

Move the open-in-editor/open-in-finder RPC recipe bundle from
devframe/recipes/open-helpers to devframe/recipes/common-rpc-functions,
renaming the exported openHelpers array to commonRpcFunctions.

devframe/recipes/open-helpers remains as a deprecated compatibility
shim (openHelpers aliased to commonRpcFunctions) so existing imports
keep working.

Author: antfubot

alias.ts

@@ -73,6 +73,7 @@ export const alias = {
   '@devframes/plugin-terminals': p('terminals/src/index.ts'),
   '@devframes/plugin-git': p('git/src/index.ts'),
   'devframe/recipes/interactive-auth': r('devframe/src/recipes/interactive-auth.ts'),
+  'devframe/recipes/common-rpc-functions': r('devframe/src/recipes/common-rpc-functions.ts'),
   'devframe/recipes/open-helpers': r('devframe/src/recipes/open-helpers.ts'),
   'devframe/client': r('devframe/src/client/index.ts'),
   'devframe': r('devframe/src'),

docs/.vitepress/config.ts

@@ -56,7 +56,7 @@ function helpersItems(prefix: string) {
     { text: 'Vite Bridge', link: `${prefix}/helpers/vite-bridge` },
     { text: 'Nuxt Module', link: `${prefix}/helpers/nuxt` },
     { text: 'Next Helper', link: `${prefix}/helpers/next` },
-    { text: 'Open Helpers', link: `${prefix}/helpers/open-helpers` },
+    { text: 'Common RPC Functions', link: `${prefix}/helpers/common-rpc-functions` },
     { text: 'Interactive Auth', link: `${prefix}/helpers/interactive-auth` },
   ] satisfies DefaultTheme.NavItemWithLink[]
 }

docs/guide/standalone-cli.md

@@ -199,9 +199,9 @@ defineDevframe({
 
 The adapter derives each flag's CAC option from its schema — booleans become `--verbose` / `--no-verbose`; everything else becomes `--depth <value>`. Keys are camelCase in TypeScript, kebab-case on the command line (`configFile` → `--config-file`). Flags that aren't in your schema (`--host`, `--port`, or anything added via `cli.configure`) still pass through untouched.
 
-## Open helpers
+## Common RPC functions
 
-For the two actions every CLI devtool needs — open a file in the editor, reveal a path in the OS file explorer — use the prebuilt recipes from `devframe/recipes/open-helpers` instead of re-implementing them. See [Helpers → Open Helpers](/helpers/open-helpers) for the full reference.
+For the two actions every CLI devtool needs — open a file in the editor, reveal a path in the OS file explorer — use the prebuilt recipes from `devframe/recipes/common-rpc-functions` instead of re-implementing them. See [Helpers → Common RPC Functions](/helpers/common-rpc-functions) for the full reference.
 
 ## Snapshot queries for static builds
 

docs/helpers/open-helpers.md docs/helpers/common-rpc-functions.mddocs/helpers/open-helpers.md renamed to docs/helpers/common-rpc-functions.md

@@ -2,18 +2,18 @@
 outline: deep
 ---
 
-# Open Helpers
+# Common RPC Functions
 
 Prebuilt RPC actions for the two file-system actions every CLI devtool needs — opening a file in the editor, revealing a path in the OS file explorer. Use the recipe instead of re-implementing them so every devframe converges on the same registered names and payload shape.
 
 ```ts
-import { openHelpers } from 'devframe/recipes/open-helpers'
+import { commonRpcFunctions } from 'devframe/recipes/common-rpc-functions'
 
 defineDevframe({
   id: 'my-tool',
   name: 'My Tool',
   setup(ctx) {
-    openHelpers.forEach(fn => ctx.rpc.register(fn))
+    commonRpcFunctions.forEach(fn => ctx.rpc.register(fn))
   },
 })
 ```
@@ -24,16 +24,18 @@ defineDevframe({
 |--------|------------------|------|------|---------|
 | `openInEditor` | `devframe:open-in-editor` | `action` | `[filename: string]` | Open the file in the user's editor via [`launchEditor`](./utilities#devframe-utils-launch-editor). Accepts `file`, `file:line`, or `file:line:column`. |
 | `openInFinder` | `devframe:open-in-finder` | `action` | `[path: string]` | Reveal the path in the OS file explorer via [`open`](./utilities#devframe-utils-open). |
-| `openHelpers` | — | `readonly [openInEditor, openInFinder]` | — | Convenience array for batch registration. |
+| `commonRpcFunctions` | — | `readonly [openInEditor, openInFinder]` | — | Convenience array for batch registration. |
 
 Both functions are `action`-type RPCs returning `void` and use `valibot` schemas (`v.string()`) for their single argument.
 
+The `devframe/recipes/open-helpers` entry (`openHelpers`) remains as a deprecated alias for this module — new code should import `commonRpcFunctions` from `devframe/recipes/common-rpc-functions`.
+
 ## Pick and choose
 
 Register only the helper you need rather than the whole array:
 
 ```ts
-import { openInEditor } from 'devframe/recipes/open-helpers'
+import { openInEditor } from 'devframe/recipes/common-rpc-functions'
 
 defineDevframe({
   id: 'my-tool',

docs/helpers/index.md

@@ -12,7 +12,7 @@ Helpers are the optional, opt-in surface around the core `defineDevframe` API: s
 | [Vite Bridge](./vite-bridge) | `devframe/helpers/vite` | Vite plugin for mounting a devframe inside any Vite-based host (Astro, SolidStart, plain Vite). |
 | [Nuxt Module](./nuxt) | `@devframes/nuxt` | Nuxt module that wires a Nuxt SPA as a devframe client and serves the dev-time RPC bridge. |
 | [Next Helper](./next) | `@devframes/next` | Route-handler host + React client for mounting devframes inside a Next.js App Router app (experimental). |
-| [Open Helpers](./open-helpers) | `devframe/recipes/open-helpers` | Prebuilt RPC actions for "open in editor" and "reveal in Finder". |
+| [Common RPC Functions](./common-rpc-functions) | `devframe/recipes/common-rpc-functions` | Prebuilt RPC actions for "open in editor" and "reveal in Finder". |
 | [Interactive Auth](./interactive-auth) | `devframe/recipes/interactive-auth` | Ready-made OTP auth layer — handshake, resolver gate, connect-time trust, and the code/link banner. |
 
 Helpers vs. [adapters](/adapters/): an adapter takes a `DevframeDefinition` and deploys it as a runnable surface (CLI, dev server, static build, MCP server). A helper is a smaller piece — a Vite plugin, a Nuxt module, a recipe, a utility function — that you compose alongside an adapter.

docs/helpers/utilities.md

@@ -46,7 +46,7 @@ launchEditor('src/main.ts:42:7')
 launchEditor('src/main.ts:42:7', 'code')
 ```
 
-The auto-detection reads the `LAUNCH_EDITOR` environment variable and falls back to common defaults. Most devframes consume this through the prebuilt `openInEditor` recipe — see [Open helpers](./open-helpers).
+The auto-detection reads the `LAUNCH_EDITOR` environment variable and falls back to common defaults. Most devframes consume this through the prebuilt `openInEditor` recipe — see [Common RPC Functions](./common-rpc-functions).
 
 ### `devframe/utils/hash`
 

packages/devframe/package.json

@@ -32,6 +32,7 @@
     "./node": "./dist/node/index.mjs",
     "./node/auth": "./dist/node/auth.mjs",
     "./node/hub-internals": "./dist/node/hub-internals.mjs",
+    "./recipes/common-rpc-functions": "./dist/recipes/common-rpc-functions.mjs",
     "./recipes/interactive-auth": "./dist/recipes/interactive-auth.mjs",
     "./recipes/open-helpers": "./dist/recipes/open-helpers.mjs",
     "./rpc": "./dist/rpc/index.mjs",

…c/recipes/__tests__/open-helpers.test.ts …s/__tests__/common-rpc-functions.test.tspackages/devframe/src/recipes/__tests__/open-helpers.test.ts renamed to packages/devframe/src/recipes/__tests__/common-rpc-functions.test.ts packages/devframe/src/recipes/__tests__/open-helpers.test.ts renamed to packages/devframe/src/recipes/__tests__/common-rpc-functions.test.ts

@@ -1,7 +1,8 @@
 import { describe, expect, it } from 'vitest'
-import { openHelpers, openInEditor, openInFinder } from '../open-helpers'
+import { commonRpcFunctions, openInEditor, openInFinder } from '../common-rpc-functions'
+import { openHelpers } from '../open-helpers'
 
-describe('recipes/open-helpers', () => {
+describe('recipes/common-rpc-functions', () => {
   it('exposes `openInEditor` as a devframe-namespaced action', () => {
     expect(openInEditor.name).toBe('devframe:open-in-editor')
     expect(openInEditor.type).toBe('action')
@@ -16,9 +17,13 @@ describe('recipes/open-helpers', () => {
     expect(typeof openInFinder.handler).toBe('function')
   })
 
-  it('bundles both helpers in `openHelpers`', () => {
-    expect(openHelpers).toHaveLength(2)
-    expect(openHelpers).toContain(openInEditor)
-    expect(openHelpers).toContain(openInFinder)
+  it('bundles both helpers in `commonRpcFunctions`', () => {
+    expect(commonRpcFunctions).toHaveLength(2)
+    expect(commonRpcFunctions).toContain(openInEditor)
+    expect(commonRpcFunctions).toContain(openInFinder)
+  })
+
+  it('keeps the deprecated `devframe/recipes/open-helpers` entry working as an alias', () => {
+    expect(openHelpers).toBe(commonRpcFunctions)
   })
 })

packages/devframe/src/recipes/common-rpc-functions.ts

@@ -0,0 +1,66 @@
+import { launchEditor } from 'devframe/utils/launch-editor'
+import { open } from 'devframe/utils/open'
+import * as v from 'valibot'
+import { defineRpcFunction } from '../rpc/define'
+
+/**
+ * Prebuilt RPC action that opens a file in the user's configured editor.
+ *
+ * Registered name: `devframe:open-in-editor`.
+ *
+ * ```ts
+ * import { openInEditor } from 'devframe/recipes/common-rpc-functions'
+ *
+ * defineDevframe({
+ *   id: 'my-tool',
+ *   name: 'My Tool',
+ *   setup(ctx) {
+ *     ctx.rpc.register(openInEditor)
+ *   },
+ * })
+ * ```
+ */
+export const openInEditor = defineRpcFunction({
+  name: 'devframe:open-in-editor',
+  type: 'action',
+  jsonSerializable: true,
+  args: [v.string()],
+  returns: v.void(),
+  async handler(filename: string) {
+    launchEditor(filename)
+  },
+})
+
+/**
+ * Prebuilt RPC action that reveals a path in the OS file explorer.
+ *
+ * Registered name: `devframe:open-in-finder`.
+ *
+ * ```ts
+ * import { openInFinder } from 'devframe/recipes/common-rpc-functions'
+ *
+ * ctx.rpc.register(openInFinder)
+ * ```
+ */
+export const openInFinder = defineRpcFunction({
+  name: 'devframe:open-in-finder',
+  type: 'action',
+  jsonSerializable: true,
+  args: [v.string()],
+  returns: v.void(),
+  async handler(path: string) {
+    await open(path)
+  },
+})
+
+/**
+ * Convenience array bundling both helpers so callers can register them
+ * in a single `forEach`.
+ *
+ * ```ts
+ * import { commonRpcFunctions } from 'devframe/recipes/common-rpc-functions'
+ *
+ * commonRpcFunctions.forEach(fn => ctx.rpc.register(fn))
+ * ```
+ */
+export const commonRpcFunctions = [openInEditor, openInFinder] as const

packages/devframe/src/recipes/open-helpers.ts

@@ -1,66 +1,12 @@
-import { launchEditor } from 'devframe/utils/launch-editor'
-import { open } from 'devframe/utils/open'
-import * as v from 'valibot'
-import { defineRpcFunction } from '../rpc/define'
+// Deprecated compatibility shim for the open helpers recipe.
+//
+// Prefer the canonical `devframe/recipes/common-rpc-functions` entry. This
+// module re-exports the same implementation under the historical name so
+// existing imports keep working. It will be removed in a future major
+// release.
+import { commonRpcFunctions } from './common-rpc-functions'
 
-/**
- * Prebuilt RPC action that opens a file in the user's configured editor.
- *
- * Registered name: `devframe:open-in-editor`.
- *
- * ```ts
- * import { openInEditor } from 'devframe/recipes/open-helpers'
- *
- * defineDevframe({
- *   id: 'my-tool',
- *   name: 'My Tool',
- *   setup(ctx) {
- *     ctx.rpc.register(openInEditor)
- *   },
- * })
- * ```
- */
-export const openInEditor = defineRpcFunction({
-  name: 'devframe:open-in-editor',
-  type: 'action',
-  jsonSerializable: true,
-  args: [v.string()],
-  returns: v.void(),
-  async handler(filename: string) {
-    launchEditor(filename)
-  },
-})
+export { openInEditor, openInFinder } from './common-rpc-functions'
 
-/**
- * Prebuilt RPC action that reveals a path in the OS file explorer.
- *
- * Registered name: `devframe:open-in-finder`.
- *
- * ```ts
- * import { openInFinder } from 'devframe/recipes/open-helpers'
- *
- * ctx.rpc.register(openInFinder)
- * ```
- */
-export const openInFinder = defineRpcFunction({
-  name: 'devframe:open-in-finder',
-  type: 'action',
-  jsonSerializable: true,
-  args: [v.string()],
-  returns: v.void(),
-  async handler(path: string) {
-    await open(path)
-  },
-})
-
-/**
- * Convenience array bundling both helpers so callers can register them
- * in a single `forEach`.
- *
- * ```ts
- * import { openHelpers } from 'devframe/recipes/open-helpers'
- *
- * openHelpers.forEach(fn => ctx.rpc.register(fn))
- * ```
- */
-export const openHelpers = [openInEditor, openInFinder] as const
+/** @deprecated Use `commonRpcFunctions` from `devframe/recipes/common-rpc-functions` instead. */
+export const openHelpers: typeof commonRpcFunctions = commonRpcFunctions