@procedures/peer 0.0.0-stage → 0.1.0

package/src/index.ts

@@ -0,0 +1,69 @@
+/**
+ * Client Server
+ *
+ * Transport-agnostic peer for bidirectional RPC.
+ * Exposes procedures and generates manifests.
+ */
+
+// Types
+export type {
+  TransportType,
+  TransportConfig,
+  HttpTransportConfig,
+  WebSocketTransportConfig,
+  LocalTransportConfig,
+  ServerCreateInput,
+  ServerCreateOutput,
+  ServerConnectInput,
+  ServerConnectOutput,
+  ServerDisconnectInput,
+  ServerDisconnectOutput,
+  ManifestGenerateInput,
+  ManifestGenerateOutput,
+  ProcedureInfo,
+  PeerConnection,
+  ProcedureAnnounceMessage,
+  ProcedureUpdateMessage,
+} from "./types.js";
+
+// Peer
+export { createPeer, type Peer, type PeerOptions, type PeerEndpoint } from "./peer/index.js";
+export { exposeRule } from "./expose.js";
+
+// Procedures
+export {
+  serverCreateProcedure,
+  getPeer,
+  getActivePeerIds,
+  serverConnectProcedure,
+  serverDisconnectProcedure,
+  manifestGenerateProcedure,
+} from "./procedures/index.js";
+
+// Manifest generation
+export {
+  generateTypeScript,
+  generateJson,
+  generateJsonString,
+  type ProcedureManifest,
+} from "./manifest/index.js";
+
+// Connection
+export {
+  connect,
+  disconnect,
+  getConnection,
+  getConnectionIds,
+  type Connection,
+  type ConnectOptions,
+} from "./connection/index.js";
+
+// Discovery
+export {
+  discoveryAnnounceProcedure,
+  getProcedureInfos,
+  watchProcedures,
+} from "./discovery/index.js";
+
+// Registration
+export { procedures, registerServerProcedures } from "./register.js";

package/src/input-schemas.ts

@@ -0,0 +1,121 @@
+/**
+ * Input schemas of the `server.*` and `manifest.*` procedures.
+ *
+ * Before, these procedures used pass-through schemas: `mark server start --help` listed no
+ * options, and a port such as "abc" reached the handler. Each schema now validates its input,
+ * and the CLI help shows the fields.
+ */
+
+import { z } from "zod";
+import { zodAdapter, type ZodLikeSchema } from "@procedures/client";
+import type {
+  ManifestGenerateInput,
+  ServerConnectInput,
+  ServerCreateInput,
+  ServerDisconnectInput,
+  ServerStartInput,
+  ServerStatusInput,
+  ServerStopInput,
+} from "./types.js";
+import type { ServerCallInput } from "./procedures/server.call.js";
+import type { ServerConnectionsInput } from "./procedures/server.connections.js";
+
+const port = z.number().int().min(1).max(65535);
+
+const httpTransport = z.object({
+  type: z.literal("http"),
+  port: port.optional(),
+  host: z.string().min(1).optional(),
+  basePath: z.string().optional(),
+  cors: z.boolean().optional(),
+  corsOrigins: z.array(z.string()).optional(),
+  urlStrategy: z.enum(["rest", "rpc"]).optional(),
+  token: z.string().min(1).optional(),
+});
+
+const webSocketTransport = z.object({
+  type: z.literal("websocket"),
+  port: port.optional(),
+  host: z.string().min(1).optional(),
+  path: z.string().optional(),
+  origins: z.array(z.string()).optional(),
+  token: z.string().min(1).optional(),
+});
+
+const localTransport = z.object({ type: z.literal("local") });
+
+export const serverCreateInputSchema: ZodLikeSchema<ServerCreateInput> = zodAdapter<ServerCreateInput>(
+  z.object({
+    transports: z
+      .array(z.discriminatedUnion("type", [httpTransport, webSocketTransport, localTransport]))
+      .optional()
+      .describe("The transports to start (default: HTTP on port 3000)"),
+    autoRegister: z.boolean().optional().describe("Serve every procedure of the registry (default: true)"),
+    token: z.string().min(1).optional().describe("A secret that every request must send"),
+    expose: z
+      .array(z.string().min(1))
+      .optional()
+      .describe("The procedures to serve: exact keys (git.status) or prefixes (git.*). Default: every procedure"),
+  })
+);
+
+export const serverStartInputSchema: ZodLikeSchema<ServerStartInput> = zodAdapter<ServerStartInput>(
+  z.object({
+    port: port.optional().describe("The port to listen on (default: 3000)"),
+    host: z.string().min(1).optional().describe("The host to bind to (default: 127.0.0.1)"),
+    transport: z.enum(["http", "websocket", "both"]).optional().describe("The transport (default: http)"),
+  })
+);
+
+export const serverStopInputSchema: ZodLikeSchema<ServerStopInput> = zodAdapter<ServerStopInput>(
+  z.object({
+    port: port.optional().describe("The port of the server to stop (default: all servers)"),
+    force: z.boolean().optional().describe("Stop with SIGKILL instead of SIGTERM"),
+  })
+);
+
+export const serverStatusInputSchema: ZodLikeSchema<ServerStatusInput> = zodAdapter<ServerStatusInput>(
+  z.object({
+    port: port.optional().describe("The port of the server (default: all servers)"),
+  })
+);
+
+export const serverConnectInputSchema: ZodLikeSchema<ServerConnectInput> = zodAdapter<ServerConnectInput>(
+  z.object({
+    address: z.string().min(1).describe("The address of the remote peer"),
+    transport: z.enum(["http", "websocket", "local"]).optional().describe("The transport to use"),
+    timeout: z.number().int().positive().optional().describe("The connection timeout in milliseconds"),
+  })
+);
+
+export const serverDisconnectInputSchema: ZodLikeSchema<ServerDisconnectInput> = zodAdapter<ServerDisconnectInput>(
+  z.object({
+    connectionId: z.string().min(1).describe("The connection id from server connect"),
+  })
+);
+
+export const serverCallInputSchema: ZodLikeSchema<ServerCallInput> = zodAdapter<ServerCallInput>(
+  z
+    .object({
+      connectionId: z.string().min(1).optional().describe("The connection id from server connect"),
+      address: z.string().min(1).optional().describe("The address of a peer, for a one-time connection"),
+      path: z
+        .union([z.string().min(1), z.array(z.string().min(1)).min(1)])
+        .describe("The procedure path on the peer: dot-separated text or a list"),
+      input: z.unknown().optional().describe("The input of the remote procedure"),
+    })
+    .refine((input) => input.connectionId !== undefined || input.address !== undefined, {
+      message: "Give connectionId or address",
+    })
+);
+
+export const serverConnectionsInputSchema: ZodLikeSchema<ServerConnectionsInput> =
+  zodAdapter<ServerConnectionsInput>(z.object({}));
+
+export const manifestGenerateInputSchema: ZodLikeSchema<ManifestGenerateInput> = zodAdapter<ManifestGenerateInput>(
+  z.object({
+    formats: z.array(z.enum(["json", "typescript"])).optional().describe("The manifest formats (default: json)"),
+    namespace: z.array(z.string()).optional().describe("Only the procedures under this path"),
+    outputDir: z.string().optional().describe("The folder for the manifest files"),
+  })
+);

package/src/lockfile.ts

@@ -0,0 +1,129 @@
+/**
+ * The lockfiles of the CLI servers: one module for `mark` and the `server.*` procedures.
+ *
+ * `mark --server` writes `~/.mark/servers/<port>.lock` with its token, the folder it runs in,
+ * the build of `mark` and its peer id. Before, five copies of this logic had drifted, and a
+ * server counted as alive when its PID existed: Windows reuses PIDs, so a stale lockfile broke
+ * every `mark` command and `server stop` killed an unrelated process (deep dive CLI-4). Now a
+ * server is alive only when its health endpoint answers with the peer id of its lockfile.
+ */
+
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+
+export interface LockfileData {
+  pid: number;
+  port: number;
+  transport: string;
+  endpoint: string;
+  startedAt: string;
+  /** The secret that every request must send (`Authorization: Bearer <token>`). An older lockfile has none. */
+  token?: string;
+  /** The folder the server runs in: relative paths and default `cwd` values resolve there */
+  cwd?: string;
+  /** The build of `mark` that runs the server */
+  build?: string;
+  /** The peer id that the server's health endpoint answers */
+  peerId?: string;
+}
+
+const MARK_DIR = path.join(os.homedir(), ".mark");
+const SERVERS_DIR = path.join(MARK_DIR, "servers");
+// The single lockfile of older versions: it is read only to remove it
+const LEGACY_LOCKFILE_PATH = path.join(MARK_DIR, "server.lock");
+
+export function getMarkDir(): string {
+  return MARK_DIR;
+}
+
+export function getServersDir(): string {
+  return SERVERS_DIR;
+}
+
+function lockfilePath(port: number): string {
+  return path.join(SERVERS_DIR, `${port}.lock`);
+}
+
+/** This function writes a lockfile that only its user can read (it holds the token). */
+export function writeLockfile(data: LockfileData): void {
+  fs.mkdirSync(SERVERS_DIR, { recursive: true });
+  fs.writeFileSync(lockfilePath(data.port), JSON.stringify(data, null, 2), { mode: 0o600 });
+}
+
+export function readLockfileForPort(port: number): LockfileData | null {
+  try {
+    return JSON.parse(fs.readFileSync(lockfilePath(port), "utf-8")) as LockfileData;
+  } catch {
+    return null;
+  }
+}
+
+export function readAllLockfiles(): LockfileData[] {
+  const results: LockfileData[] = [];
+  let files: string[] = [];
+  try {
+    files = fs.readdirSync(SERVERS_DIR);
+  } catch {
+    return results; // The folder does not exist yet
+  }
+  for (const file of files) {
+    if (!file.endsWith(".lock")) continue;
+    try {
+      results.push(JSON.parse(fs.readFileSync(path.join(SERVERS_DIR, file), "utf-8")) as LockfileData);
+    } catch {
+      // Skip a corrupt lockfile
+    }
+  }
+  return results;
+}
+
+export function removeLockfileForPort(port: number): void {
+  try {
+    fs.unlinkSync(lockfilePath(port));
+  } catch {
+    // Already gone
+  }
+  try {
+    const legacy = JSON.parse(fs.readFileSync(LEGACY_LOCKFILE_PATH, "utf-8")) as LockfileData;
+    if (legacy.port === port) fs.unlinkSync(LEGACY_LOCKFILE_PATH);
+  } catch {
+    // No legacy lockfile
+  }
+}
+
+/**
+ * The state of a lockfile's server:
+ * - "alive": the health endpoint answers with the lockfile's peer id;
+ * - "dead": nothing answers (the lockfile is stale);
+ * - "other": something else answers on the port (another server, or a lockfile without a peer id).
+ */
+export async function checkServer(lockfile: LockfileData, timeoutMs = 1000): Promise<"alive" | "dead" | "other"> {
+  let response: Response;
+  try {
+    response = await fetch(`${lockfile.endpoint}/health`, { signal: AbortSignal.timeout(timeoutMs) });
+  } catch {
+    return "dead";
+  }
+  try {
+    const health = (await response.json()) as { peerId?: unknown };
+    return lockfile.peerId !== undefined && health.peerId === lockfile.peerId ? "alive" : "other";
+  } catch {
+    return "other";
+  }
+}
+
+/**
+ * The lockfile of a running server that this caller can use: it has a token, it runs in `cwd`
+ * with the build `build`, and it answers as the peer of its lockfile. A dead server's lockfile
+ * is removed.
+ */
+export async function findServer(match: { cwd: string; build: string }): Promise<LockfileData | null> {
+  for (const lockfile of readAllLockfiles()) {
+    if (!lockfile.token || lockfile.cwd !== match.cwd || lockfile.build !== match.build) continue;
+    const state = await checkServer(lockfile);
+    if (state === "alive") return lockfile;
+    if (state === "dead") removeLockfileForPort(lockfile.port);
+  }
+  return null;
+}

package/src/manifest/index.ts

@@ -0,0 +1,8 @@
+/**
+ * Manifest Generation Module
+ *
+ * Generates procedure manifests in various formats.
+ */
+
+export { generateTypeScript } from "./typescript.js";
+export { generateJson, generateJsonString, type ProcedureManifest } from "./json.js";

package/src/manifest/json.ts

@@ -0,0 +1,39 @@
+/**
+ * JSON Manifest Generator
+ *
+ * Generates JSON manifests from procedure definitions
+ * for runtime discovery and visualization.
+ */
+
+import type { ProcedureInfo } from "../types.js";
+
+/**
+ * JSON manifest structure
+ */
+export interface ProcedureManifest {
+  /** Manifest version */
+  version: string;
+  /** Generation timestamp */
+  generatedAt: string;
+  /** All procedures */
+  procedures: ProcedureInfo[];
+}
+
+/**
+ * Generate JSON manifest
+ */
+export function generateJson(procedures: ProcedureInfo[]): ProcedureManifest {
+  return {
+    version: "1.0.0",
+    generatedAt: new Date().toISOString(),
+    procedures,
+  };
+}
+
+/**
+ * Generate JSON string (formatted)
+ */
+export function generateJsonString(procedures: ProcedureInfo[]): string {
+  const manifest = generateJson(procedures);
+  return JSON.stringify(manifest, null, 2);
+}

package/src/manifest/typescript.ts

@@ -0,0 +1,148 @@
+/**
+ * TypeScript Declaration Generator
+ *
+ * Generates .d.ts files from procedure definitions
+ * for static type checking on clients.
+ */
+
+import type { ProcedureInfo } from "../types.js";
+
+/**
+ * Generate TypeScript declaration file content
+ */
+export function generateTypeScript(procedures: ProcedureInfo[]): string {
+  const lines: string[] = [
+    "/**",
+    " * Auto-generated procedure type declarations",
+    ` * Generated at: ${new Date().toISOString()}`,
+    " */",
+    "",
+  ];
+
+  // Group procedures by namespace (first path segment)
+  const namespaces = new Map<string, ProcedureInfo[]>();
+
+  for (const proc of procedures) {
+    const namespace = proc.path[0] ?? "root";
+    const existing = namespaces.get(namespace) ?? [];
+    existing.push(proc);
+    namespaces.set(namespace, existing);
+  }
+
+  // Generate interface for each namespace
+  for (const [namespace, procs] of namespaces) {
+    lines.push(`export interface ${pascalCase(namespace)}Procedures {`);
+
+    for (const proc of procs) {
+      const path = proc.path.slice(1);
+      const methodName = path.join("_") || namespace;
+
+      if (proc.description) {
+        lines.push(`  /** ${proc.description} */`);
+      }
+
+      // The types come from the JSON Schemas; a procedure without one has `unknown`
+      lines.push(`  ${camelCase(methodName)}: {`);
+      lines.push(`    path: ${JSON.stringify(proc.path)};`);
+      lines.push(`    input: ${jsonSchemaToTs(proc.inputSchema, "    ")};`);
+      lines.push(`    output: ${jsonSchemaToTs(proc.outputSchema, "    ")};`);
+      lines.push(`  };`);
+    }
+
+    lines.push(`}`);
+    lines.push("");
+  }
+
+  // Generate combined type
+  lines.push("export interface RemoteProcedures {");
+  for (const namespace of namespaces.keys()) {
+    lines.push(`  ${camelCase(namespace)}: ${pascalCase(namespace)}Procedures;`);
+  }
+  lines.push("}");
+  lines.push("");
+
+  return lines.join("\n");
+}
+
+/** A JSON Schema node, as the manifest stores it. */
+interface JsonNode {
+  type?: string | string[];
+  enum?: unknown[];
+  const?: unknown;
+  items?: JsonNode | JsonNode[];
+  properties?: Record<string, JsonNode>;
+  required?: string[];
+  additionalProperties?: boolean | JsonNode;
+  anyOf?: JsonNode[];
+  oneOf?: JsonNode[];
+  allOf?: JsonNode[];
+}
+
+/** A property name as TypeScript writes it: quoted when it is not an identifier. */
+function propertyName(name: string): string {
+  return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(name) ? name : JSON.stringify(name);
+}
+
+/**
+ * The TypeScript type of a JSON Schema: objects, arrays, records, enums, constants and unions.
+ * A schema that it cannot read is `unknown`.
+ */
+export function jsonSchemaToTs(schema: unknown, indent = ""): string {
+  if (!schema || typeof schema !== "object") return "unknown";
+  const node = schema as JsonNode;
+  const union = node.anyOf ?? node.oneOf;
+  if (union?.length) return union.map((member) => jsonSchemaToTs(member, indent)).join(" | ");
+  if (node.allOf?.length) return node.allOf.map((member) => jsonSchemaToTs(member, indent)).join(" & ");
+  if (Array.isArray(node.enum)) return node.enum.map((value) => JSON.stringify(value)).join(" | ") || "never";
+  if (node.const !== undefined) return JSON.stringify(node.const);
+  const types = Array.isArray(node.type) ? node.type : node.type ? [node.type] : [];
+  if (types.length > 1) return types.map((type) => jsonSchemaToTs({ ...node, type }, indent)).join(" | ");
+  switch (types[0]) {
+    case "string":
+      return "string";
+    case "number":
+    case "integer":
+      return "number";
+    case "boolean":
+      return "boolean";
+    case "null":
+      return "null";
+    case "array":
+      return Array.isArray(node.items)
+        ? `[${node.items.map((part) => jsonSchemaToTs(part, indent)).join(", ")}]`
+        : `Array<${jsonSchemaToTs(node.items, indent)}>`;
+    case "object": {
+      const properties = Object.entries(node.properties ?? {});
+      const extra = node.additionalProperties;
+      if (properties.length === 0) {
+        return extra && typeof extra === "object" ? `Record<string, ${jsonSchemaToTs(extra, indent)}>` : "Record<string, unknown>";
+      }
+      const required = new Set(node.required ?? []);
+      const inner = `${indent}  `;
+      const members = properties.map(
+        ([name, value]) => `${inner}${propertyName(name)}${required.has(name) ? "" : "?"}: ${jsonSchemaToTs(value, inner)};`
+      );
+      return `{\n${members.join("\n")}\n${indent}}`;
+    }
+    default:
+      return "unknown";
+  }
+}
+
+/**
+ * Convert string to PascalCase
+ */
+function pascalCase(str: string): string {
+  return str
+    .split(/[-_\s]+/)
+    .map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
+    .join("");
+}
+
+/**
+ * Convert string to camelCase
+ */
+function camelCase(str: string): string {
+  const pascal = pascalCase(str);
+  return pascal.charAt(0).toLowerCase() + pascal.slice(1);
+}

package/src/module.ts

@@ -0,0 +1,46 @@
+/**
+ * Module (no side effects): the procedures of this package as data, for `createRegistry()`.
+ *
+ * Procedure Registration
+ *
+ * Registers server procedures with the client system.
+ * This file is referenced by package.json's client.procedures field.
+ */
+
+import { type AnyProcedure, defineModule, type ProcedureModule } from "@procedures/client";
+
+// Import all procedures
+import { serverCreateProcedure } from "./procedures/server.create.js";
+import { serverConnectProcedure } from "./procedures/server.connect.js";
+import { serverDisconnectProcedure } from "./procedures/server.disconnect.js";
+import { manifestGenerateProcedure } from "./procedures/manifest.generate.js";
+import { discoveryAnnounceProcedure } from "./discovery/index.js";
+import { serverStartProcedure } from "./procedures/server.start.js";
+import { serverStopProcedure } from "./procedures/server.stop.js";
+import { serverStatusProcedure } from "./procedures/server.status.js";
+import { serverCallProcedure } from "./procedures/server.call.js";
+import { serverConnectionsProcedure } from "./procedures/server.connections.js";
+
+/**
+ * All server procedures
+ */
+export const procedures: readonly AnyProcedure[] = [
+  serverCreateProcedure,
+  serverConnectProcedure,
+  serverDisconnectProcedure,
+  manifestGenerateProcedure,
+  discoveryAnnounceProcedure,
+  serverStartProcedure,
+  serverStopProcedure,
+  serverStatusProcedure,
+  serverCallProcedure,
+  serverConnectionsProcedure,
+];
+
+/**
+ * The module of this package, for `createRegistry()`: its procedures as data. Importing this
+ * file registers nothing. (`register.ts` registers the same procedures in the global registry.)
+ */
+export const serverModule: ProcedureModule = defineModule("@procedures/peer", [...procedures]);
+
+export default serverModule;

package/src/output-schemas.ts

@@ -0,0 +1,110 @@
+/**
+ * The output schemas of the server.* and manifest.* procedures (roadmap 2.1).
+ *
+ * Loose objects: a field that a schema does not name stays in the result (a strict schema would
+ * remove it when the output is validated). Each schema is a `z.ZodType` of its output type, so
+ * the compiler checks it against the type.
+ */
+
+import { z } from "zod";
+import type {
+  ManifestGenerateOutput,
+  ServerConnectOutput,
+  ServerCreateOutput,
+  ServerDisconnectOutput,
+  ServerStartOutput,
+  ServerStatusOutput,
+  ServerStopOutput,
+} from "./types.js";
+import type { ServerCallOutput } from "./procedures/server.call.js";
+import type { ServerConnectionsOutput } from "./procedures/server.connections.js";
+
+const procedureInfo = z.looseObject({
+  path: z.array(z.string()).describe("The procedure path"),
+  description: z.string().optional().describe("The description of the procedure"),
+  inputSchema: z.record(z.string(), z.unknown()).optional().describe("The JSON Schema of the input"),
+  outputSchema: z.record(z.string(), z.unknown()).optional().describe("The JSON Schema of the output"),
+});
+
+export const ServerCreateOutputSchema: z.ZodType<ServerCreateOutput> = z.looseObject({
+  serverId: z.string().describe("The id of the server: server.stop takes it"),
+  endpoints: z
+    .array(
+      z.looseObject({
+        type: z.enum(["http", "websocket", "local"]).describe("The transport"),
+        address: z.string().describe("The address of the endpoint"),
+      })
+    )
+    .describe("The endpoints of the server"),
+  procedureCount: z.number().describe("The number of procedures that the server serves"),
+});
+
+export const ServerConnectOutputSchema: z.ZodType<ServerConnectOutput> = z.looseObject({
+  connectionId: z.string().describe("The id of the connection: server.call and server.disconnect take it"),
+  remotePeerId: z.string().describe("The id of the remote peer"),
+  remoteProcedures: z.array(procedureInfo).describe("The procedures of the remote peer"),
+});
+
+export const ServerDisconnectOutputSchema: z.ZodType<ServerDisconnectOutput> = z.looseObject({
+  success: z.boolean().describe("True when the connection closed"),
+});
+
+export const ManifestGenerateOutputSchema: z.ZodType<ManifestGenerateOutput> = z.looseObject({
+  json: z
+    .looseObject({
+      procedures: z.array(procedureInfo).describe("The procedures with their JSON Schemas"),
+      generatedAt: z.string().describe("The time of the manifest (ISO 8601)"),
+      version: z.string().describe("The version of the manifest format"),
+    })
+    .optional()
+    .describe("The JSON manifest, for the json format"),
+  typescript: z.string().optional().describe("The TypeScript declarations, for the typescript format"),
+  filesWritten: z.array(z.string()).optional().describe("The files that the call wrote, with outputDir"),
+});
+
+export const ServerStartOutputSchema: z.ZodType<ServerStartOutput> = z.looseObject({
+  success: z.boolean().describe("True when the server started"),
+  pid: z.number().optional().describe("The process id of the server"),
+  port: z.number().optional().describe("The port of the server"),
+  endpoint: z.string().optional().describe("The URL of the server"),
+  logFile: z.string().optional().describe("The log file of the server"),
+  message: z.string().describe("A message about the result"),
+});
+
+export const ServerStopOutputSchema: z.ZodType<ServerStopOutput> = z.looseObject({
+  success: z.boolean().describe("True when the server stopped"),
+  message: z.string().describe("A message about the result"),
+});
+
+export const ServerStatusOutputSchema: z.ZodType<ServerStatusOutput> = z.looseObject({
+  running: z.boolean().describe("True when a server runs"),
+  pid: z.number().optional().describe("The process id of the server"),
+  port: z.number().optional().describe("The port of the server"),
+  endpoint: z.string().optional().describe("The URL of the server"),
+  transport: z.string().optional().describe("The transport of the server"),
+  startedAt: z.string().optional().describe("The start time (ISO 8601)"),
+  uptime: z.string().optional().describe("The time since the start, as text"),
+  logFile: z.string().optional().describe("The log file of the server"),
+  message: z.string().describe("A message about the result"),
+});
+
+export const ServerCallOutputSchema: z.ZodType<ServerCallOutput> = z.looseObject({
+  result: z.unknown().describe("The result of the remote procedure"),
+  connectionId: z.string().describe("The connection that the call used"),
+  path: z.array(z.string()).describe("The path of the remote procedure"),
+});
+
+export const ServerConnectionsOutputSchema: z.ZodType<ServerConnectionsOutput> = z.looseObject({
+  connections: z
+    .array(
+      z.looseObject({
+        connectionId: z.string().describe("The id of the connection"),
+        remotePeerId: z.string().describe("The id of the remote peer"),
+        transport: z.string().describe("The transport of the connection"),
+        state: z.string().describe("The state: connecting, connected, disconnected or error"),
+        remoteProcedureCount: z.number().describe("The number of procedures of the remote peer"),
+        connectedAt: z.string().optional().describe("The time of the connection (ISO 8601)"),
+      })
+    )
+    .describe("The open connections"),
+});