@devframes/plugin-inspect 0.7.16 → 0.8.1

package/README.md

@@ -7,7 +7,9 @@
 A devframe plugin that inspects *its own* connection (and, when mounted in a
 host, the host's): browse every registered RPC function with its metadata,
 invoke read-only `query`/`static` functions and inspect the results, watch
-shared-state keys update live, and explore the agent-exposed surface.
+shared-state keys update live, explore the agent-exposed surface, and — while
+running against a live backend — list the other devframe dev servers running
+alongside it.
 
 Ported in spirit from the RPC & State panels of
 [`vitejs/devtools`](https://github.com/vitejs/devtools); rebuilt on devframe's
@@ -54,7 +56,10 @@ All functions are namespaced `devframes:plugin:inspect:*`:
 | `invoke` | `action` | Invokes a read-only `query`/`static` function by name and returns a result envelope. Refuses `action`/`event` functions. |
 | `list-state-keys` | `query` (snapshot) | The keys of every shared-state entry on the connection. |
 | `describe-agent` | `query` (snapshot) | The agent manifest — tools and readable resources. |
+| `list-instances` | `query` (live) | Every devframe dev server currently running on the machine, discovered through the shared instance registry. Powers the read-only Instances tab. |
 
-The three `query` functions are agent-exposed (read-only) and bake into the
-static dump, so the inspector still lists functions, state keys, and the agent
-surface when deployed as a static SPA.
+The three snapshot `query` functions are agent-exposed (read-only) and bake into
+the static dump, so the inspector still lists functions, state keys, and the
+agent surface when deployed as a static SPA. `list-instances` is live rather
+than baked (the set of running processes is meaningless in a static dump), so
+the Instances tab appears only against a live backend.

package/dist/cli.mjs

@@ -1,4 +1,4 @@
-import { n as inspectDevframe } from "./src-B0I3jZUe.mjs";
+import { n as inspectDevframe } from "./src-DE4XzhQt.mjs";
 import { createCac } from "devframe/adapters/cac";
 //#region src/cli.ts
 /**

package/dist/client/index.d.mts

@@ -1,4 +1,4 @@
-import { a as RpcFunctionInfo, i as RpcFunctionAgentInfo, n as DevframeInspectCommandInfo, r as InvokeResult, t as AgentManifest } from "../types-C1KvyFRp.mjs";
+import { a as RpcFunctionAgentInfo, i as InvokeResult, n as DevframeInspectCommandInfo, o as RpcFunctionInfo, r as DevframeInspectInstanceInfo, t as AgentManifest } from "../types-_vo7QhmS.mjs";
 import { DevframeConnectionStatus, DevframeRpcClient, DevframeRpcClientOptions } from "devframe/client";
 //#region src/client/index.d.ts
 /**
@@ -8,4 +8,4 @@ import { DevframeConnectionStatus, DevframeRpcClient, DevframeRpcClientOptions }
  */
 declare function connectInspect(options?: DevframeRpcClientOptions): Promise<DevframeRpcClient>;
 //#endregion
-export { type AgentManifest, type DevframeConnectionStatus, type DevframeInspectCommandInfo, type DevframeRpcClient, type InvokeResult, type RpcFunctionAgentInfo, type RpcFunctionInfo, connectInspect };
+export { type AgentManifest, type DevframeConnectionStatus, type DevframeInspectCommandInfo, type DevframeInspectInstanceInfo, type DevframeRpcClient, type InvokeResult, type RpcFunctionAgentInfo, type RpcFunctionInfo, connectInspect };

package/dist/{index-HaJd7k1e.d.mts → index-B7KBbd3U.d.mts}

@@ -1,4 +1,4 @@
-import "./types-C1KvyFRp.mjs";
+import "./types-_vo7QhmS.mjs";
 import { DevframeDefinition } from "devframe/types";
 //#region src/index.d.ts
 interface InspectDevframeOptions {

package/dist/index.d.mts

@@ -1,3 +1,3 @@
-import { a as RpcFunctionInfo, r as InvokeResult } from "./types-C1KvyFRp.mjs";
-import { n as createInspectDevframe, r as inspectDevframe, t as InspectDevframeOptions } from "./index-HaJd7k1e.mjs";
+import { i as InvokeResult, o as RpcFunctionInfo } from "./types-_vo7QhmS.mjs";
+import { n as createInspectDevframe, r as inspectDevframe, t as InspectDevframeOptions } from "./index-B7KBbd3U.mjs";
 export { InspectDevframeOptions, type InvokeResult, type RpcFunctionInfo, createInspectDevframe, inspectDevframe as default };

package/dist/index.mjs

@@ -1,2 +1,2 @@
-import { n as inspectDevframe, t as createInspectDevframe } from "./src-B0I3jZUe.mjs";
+import { n as inspectDevframe, t as createInspectDevframe } from "./src-DE4XzhQt.mjs";
 export { createInspectDevframe, inspectDevframe as default };

package/dist/node/index.mjs

@@ -1,4 +1,4 @@
-import { t as serverFunctions } from "../rpc-Blq-HUIF.mjs";
+import { t as serverFunctions } from "../rpc-BCuMcHnd.mjs";
 //#region src/node/index.ts
 /**
 * Register the inspector's introspection RPC functions on a devframe

package/dist/rpc/index.d.mts

@@ -1,5 +1,5 @@
-import { a as RpcFunctionInfo, n as DevframeInspectCommandInfo, r as InvokeResult } from "../types-C1KvyFRp.mjs";
-import "../index-HaJd7k1e.mjs";
+import { i as InvokeResult, n as DevframeInspectCommandInfo, o as RpcFunctionInfo, r as DevframeInspectInstanceInfo } from "../types-_vo7QhmS.mjs";
+import "../index-B7KBbd3U.mjs";
 import { RpcDefinitionsToFunctions } from "devframe/rpc";
 //#region src/rpc/index.d.ts
 /**
@@ -118,6 +118,20 @@ declare const serverFunctions: readonly [{
   snapshot?: boolean;
   __cache?: WeakMap<object, import("devframe/rpc").Thenable<import("devframe/rpc").RpcFunctionSetupResult<[id: string, args?: unknown[] | undefined], Promise<InvokeResult>>>> | undefined;
   __promise?: import("devframe/rpc").Thenable<import("devframe/rpc").RpcFunctionSetupResult<[id: string, args?: unknown[] | undefined], Promise<InvokeResult>>> | undefined;
+}, {
+  name: "devframes:plugin:inspect:list-instances";
+  type?: "query" | undefined;
+  cacheable?: boolean;
+  args?: undefined;
+  returns?: undefined;
+  jsonSerializable?: boolean;
+  agent?: import("devframe").RpcFunctionAgentOptions;
+  setup?: ((context: import("devframe").DevframeNodeContext) => import("devframe/rpc").Thenable<import("devframe/rpc").RpcFunctionSetupResult<[], Promise<DevframeInspectInstanceInfo[]>>>) | undefined;
+  handler?: (() => Promise<DevframeInspectInstanceInfo[]>) | undefined;
+  dump?: import("devframe/rpc").RpcDump<[], Promise<DevframeInspectInstanceInfo[]>, import("devframe").DevframeNodeContext> | undefined;
+  snapshot?: boolean;
+  __cache?: WeakMap<object, import("devframe/rpc").Thenable<import("devframe/rpc").RpcFunctionSetupResult<[], Promise<DevframeInspectInstanceInfo[]>>>> | undefined;
+  __promise?: import("devframe/rpc").Thenable<import("devframe/rpc").RpcFunctionSetupResult<[], Promise<DevframeInspectInstanceInfo[]>>> | undefined;
 }];
 declare module 'devframe' {
   interface DevframeRpcServerFunctions extends RpcDefinitionsToFunctions<typeof serverFunctions> {}

package/dist/rpc/index.mjs

@@ -1,2 +1,2 @@
-import { t as serverFunctions } from "../rpc-Blq-HUIF.mjs";
+import { t as serverFunctions } from "../rpc-BCuMcHnd.mjs";
 export { serverFunctions };

package/dist/{rpc-Blq-HUIF.mjs → rpc-BCuMcHnd.mjs}

@@ -1,6 +1,8 @@
 import { createDefineWrapperWithContext } from "devframe/rpc";
 import { defineDiagnostics } from "nostics";
 import { toJsonSchema } from "@valibot/to-json-schema";
+import process from "node:process";
+import { listLiveDevframeInstances } from "devframe/node";
 //#region src/rpc/functions/_define.ts
 /**
 * `defineRpcFunction` pre-bound to the framework-neutral
@@ -236,39 +238,128 @@ const FALLBACK_SCHEMA = Object.freeze({
 	additionalProperties: true
 });
 /**
-* Convert a valibot return schema to JSON Schema, swallowing
-* conversion failures (unsupported valibot actions) into a permissive
-* fallback so introspection never throws.
+* Convert a schema to JSON Schema for the inspector, vendor-neutrally.
+*
+* Prefers the schema's own Standard JSON Schema converter
+* (`~standard.jsonSchema`, implemented by e.g. zod 4), then falls back to
+* valibot's converter, then to a permissive object — so introspection never
+* throws regardless of which validator produced the schema.
 */
-function returnSchemaToJson(schema) {
-	if (!schema) return void 0;
+function convert(schema) {
+	const standard = schema["~standard"];
 	try {
+		if (standard.jsonSchema) return standard.jsonSchema.input({ target: "draft-2020-12" });
 		return toJsonSchema(schema);
 	} catch {
 		return FALLBACK_SCHEMA;
 	}
 }
 /**
-* Convert the positional args valibot schemas to a single JSON Schema
-* tuple (`type: 'array'` + `prefixItems`). Returns `undefined` when the
-* function declares no args.
+* Convert an RPC return schema to JSON Schema, swallowing conversion
+* failures into a permissive fallback so introspection never throws.
+*/
+function returnSchemaToJson(schema) {
+	if (!schema) return void 0;
+	return convert(schema);
+}
+/**
+* Convert positional args schemas to a single JSON Schema tuple
+* (`type: 'array'` + `prefixItems`). Returns `undefined` when the function
+* declares no args.
 */
 function argsSchemaToJson(args) {
 	if (!args || args.length === 0) return void 0;
 	return {
 		type: "array",
-		prefixItems: args.map((arg) => {
-			try {
-				return toJsonSchema(arg);
-			} catch {
-				return FALLBACK_SCHEMA;
-			}
-		})
+		prefixItems: args.map((arg) => convert(arg))
 	};
 }
 //#endregion
 //#region src/rpc/functions/list-functions.ts
 const INVOKABLE_TYPES = /* @__PURE__ */ new Set(["query", "static"]);
+/**
+* Enumerate every RPC function registered on the connection, projecting
+* each definition's metadata into a JSON-safe {@link RpcFunctionInfo}.
+* `snapshot: true` bakes the registry into the static dump so the
+* inspector still lists functions in `build`/`spa` mode.
+*/
+const listFunctions = defineInspectRpc({
+	name: "devframes:plugin:inspect:list-functions",
+	type: "query",
+	jsonSerializable: true,
+	snapshot: true,
+	agent: {
+		description: "List every RPC function registered on this devframe connection, with metadata (name, type, JSON-serializable/snapshot flags, args/return schema, agent exposure). Read-only — the canonical way to discover what the running devframe can do.",
+		title: "List RPC functions"
+	},
+	setup: (ctx) => ({ handler: async () => {
+		const out = [];
+		for (const [name, fn] of ctx.rpc.definitions) {
+			const type = fn.type ?? "query";
+			let agent;
+			if (fn.agent) agent = {
+				description: fn.agent.description,
+				title: fn.agent.title,
+				safety: fn.agent.safety,
+				tags: fn.agent.tags
+			};
+			out.push({
+				name,
+				type,
+				jsonSerializable: fn.jsonSerializable === true,
+				snapshot: fn.snapshot === true,
+				cacheable: fn.cacheable === true,
+				hasArgs: !!fn.args,
+				hasReturns: !!fn.returns,
+				hasDump: !!fn.dump,
+				hasSetup: !!fn.setup,
+				hasHandler: !!fn.handler,
+				invokable: INVOKABLE_TYPES.has(type),
+				agent,
+				argsSchema: argsSchemaToJson(fn.args),
+				returnsSchema: returnSchemaToJson(fn.returns)
+			});
+		}
+		out.sort((a, b) => a.name.localeCompare(b.name));
+		return out;
+	} })
+});
+//#endregion
+//#region src/rpc/functions/list-instances.ts
+/**
+* Enumerate every devframe dev server currently running on this machine,
+* discovered through the shared instance registry (`~/.devframe/instances/`)
+* with a `__connection.json` liveness probe — the same discovery that backs
+* the `devframe connect` bin. Powers the inspector's read-only Instances tab.
+*
+* Deliberately **not** `snapshot` (the set of live processes is meaningless
+* baked into a static dump — the Instances tab is hidden in `build`/`spa`
+* mode) and **not** agent-exposed (the `devframe connect` bin already offers
+* instance discovery to agents over MCP, so exposing it here would duplicate
+* that surface).
+*/
+const listInstances = defineInspectRpc({
+	name: "devframes:plugin:inspect:list-instances",
+	type: "query",
+	jsonSerializable: true,
+	setup: () => ({ handler: async () => {
+		const { live } = await listLiveDevframeInstances();
+		const currentPid = process.pid;
+		return live.map((record) => ({
+			id: record.id,
+			name: record.name,
+			port: record.port,
+			origin: record.origin,
+			basePath: record.basePath,
+			url: `${record.origin}${record.basePath}`,
+			pid: record.pid,
+			rootDir: record.rootDir,
+			startedAt: record.startedAt,
+			hasMcp: record.mcp != null,
+			isCurrent: record.pid === currentPid
+		}));
+	} })
+});
 //#endregion
 //#region src/rpc/index.ts
 /**
@@ -276,47 +367,7 @@ const INVOKABLE_TYPES = /* @__PURE__ */ new Set(["query", "static"]);
 * Namespaced `devframes:plugin:inspect:*` per the plugin convention.
 */
 const serverFunctions = [
-	defineInspectRpc({
-		name: "devframes:plugin:inspect:list-functions",
-		type: "query",
-		jsonSerializable: true,
-		snapshot: true,
-		agent: {
-			description: "List every RPC function registered on this devframe connection, with metadata (name, type, JSON-serializable/snapshot flags, args/return schema, agent exposure). Read-only — the canonical way to discover what the running devframe can do.",
-			title: "List RPC functions"
-		},
-		setup: (ctx) => ({ handler: async () => {
-			const out = [];
-			for (const [name, fn] of ctx.rpc.definitions) {
-				const type = fn.type ?? "query";
-				let agent;
-				if (fn.agent) agent = {
-					description: fn.agent.description,
-					title: fn.agent.title,
-					safety: fn.agent.safety,
-					tags: fn.agent.tags
-				};
-				out.push({
-					name,
-					type,
-					jsonSerializable: fn.jsonSerializable === true,
-					snapshot: fn.snapshot === true,
-					cacheable: fn.cacheable === true,
-					hasArgs: !!fn.args,
-					hasReturns: !!fn.returns,
-					hasDump: !!fn.dump,
-					hasSetup: !!fn.setup,
-					hasHandler: !!fn.handler,
-					invokable: INVOKABLE_TYPES.has(type),
-					agent,
-					argsSchema: argsSchemaToJson(fn.args),
-					returnsSchema: returnSchemaToJson(fn.returns)
-				});
-			}
-			out.sort((a, b) => a.name.localeCompare(b.name));
-			return out;
-		} })
-	}),
+	listFunctions,
 	invoke,
 	defineInspectRpc({
 		name: "devframes:plugin:inspect:list-state-keys",
@@ -359,7 +410,8 @@ const serverFunctions = [
 		} })
 	}),
 	listCommands,
-	executeCommand
+	executeCommand,
+	listInstances
 ];
 //#endregion
 export { serverFunctions as t };