@openspecui/server 0.9.0

package/dist/index.mjs

@@ -0,0 +1,680 @@
+import { serve } from "@hono/node-server";
+import { Hono } from "hono";
+import { cors } from "hono/cors";
+import { fetchRequestHandler } from "@trpc/server/adapters/fetch";
+import { applyWSSHandler } from "@trpc/server/adapters/ws";
+import { WebSocketServer } from "ws";
+import { CliExecutor, ConfigManager, OpenSpecAdapter, OpenSpecWatcher, ReactiveContext, getAllTools, getAvailableTools, getConfiguredTools, getDefaultCliCommandString, initWatcherPool, sniffGlobalCli } from "@openspecui/core";
+import { initTRPC } from "@trpc/server";
+import { observable } from "@trpc/server/observable";
+import { z } from "zod";
+import { createServer as createServer$1 } from "node:net";
+
+//#region src/reactive-subscription.ts
+/**
+* 创建响应式订阅
+*
+* 自动追踪 task 中的文件依赖，当依赖变更时自动重新执行并推送新数据。
+*
+* @param task 要执行的异步任务，内部的文件读取会被自动追踪
+* @returns tRPC observable
+*
+* @example
+* ```typescript
+* // 在 router 中使用
+* subscribe: publicProcedure.subscription(({ ctx }) => {
+*   return createReactiveSubscription(() => ctx.adapter.listSpecsWithMeta())
+* })
+* ```
+*/
+function createReactiveSubscription(task) {
+	return observable((emit) => {
+		const context = new ReactiveContext();
+		const controller = new AbortController();
+		(async () => {
+			try {
+				for await (const data of context.stream(task, controller.signal)) emit.next(data);
+			} catch (err) {
+				if (!controller.signal.aborted) emit.error(err);
+			}
+		})();
+		return () => {
+			controller.abort();
+		};
+	});
+}
+/**
+* 创建带输入参数的响应式订阅
+*
+* @param task 接收输入参数的异步任务
+* @returns 返回一个函数，接收输入参数并返回 tRPC observable
+*
+* @example
+* ```typescript
+* // 在 router 中使用
+* subscribeOne: publicProcedure
+*   .input(z.object({ id: z.string() }))
+*   .subscription(({ ctx, input }) => {
+*     return createReactiveSubscriptionWithInput(
+*       (id: string) => ctx.adapter.readSpec(id)
+*     )(input.id)
+*   })
+* ```
+*/
+function createReactiveSubscriptionWithInput(task) {
+	return (input) => {
+		return createReactiveSubscription(() => task(input));
+	};
+}
+
+//#endregion
+//#region src/cli-stream-observable.ts
+/**
+* 创建安全的 CLI 流式 observable
+*
+* 解决的问题：
+* 1. 防止在 emit.complete() 之后调用 emit.next()（会导致 "Controller is already closed" 错误）
+* 2. 统一的错误处理，防止未捕获的异常导致服务器崩溃
+* 3. 确保取消时正确清理资源
+*
+* @param startStream 启动流的函数，接收 onEvent 回调，返回取消函数的 Promise
+*/
+function createCliStreamObservable(startStream) {
+	return observable((emit) => {
+		let cancel;
+		let completed = false;
+		/**
+		* 安全的事件处理器
+		* - 检查是否已完成，防止重复调用
+		* - 使用 try-catch 防止异常导致服务器崩溃
+		*/
+		const safeEventHandler = (event) => {
+			if (completed) return;
+			try {
+				emit.next(event);
+				if (event.type === "exit") {
+					completed = true;
+					emit.complete();
+				}
+			} catch (err) {
+				console.error("[CLI Stream] Error emitting event:", err);
+				if (!completed) {
+					completed = true;
+					try {
+						emit.error(err instanceof Error ? err : new Error(String(err)));
+					} catch {}
+				}
+			}
+		};
+		startStream(safeEventHandler).then((cancelFn) => {
+			cancel = cancelFn;
+		}).catch((err) => {
+			console.error("[CLI Stream] Error starting stream:", err);
+			if (!completed) {
+				completed = true;
+				try {
+					emit.error(err instanceof Error ? err : new Error(String(err)));
+				} catch {}
+			}
+		});
+		return () => {
+			completed = true;
+			cancel?.();
+		};
+	});
+}
+
+//#endregion
+//#region src/router.ts
+const t = initTRPC.context().create();
+const router = t.router;
+const publicProcedure = t.procedure;
+/**
+* Dashboard router - overview and status
+*/
+const dashboardRouter = router({
+	getData: publicProcedure.query(async ({ ctx }) => {
+		return ctx.adapter.getDashboardData();
+	}),
+	isInitialized: publicProcedure.query(async ({ ctx }) => {
+		return ctx.adapter.isInitialized();
+	}),
+	subscribe: publicProcedure.subscription(({ ctx }) => {
+		return createReactiveSubscription(() => ctx.adapter.getDashboardData());
+	}),
+	subscribeInitialized: publicProcedure.subscription(({ ctx }) => {
+		return createReactiveSubscription(() => ctx.adapter.isInitialized());
+	})
+});
+/**
+* Spec router - spec CRUD operations
+*/
+const specRouter = router({
+	list: publicProcedure.query(async ({ ctx }) => {
+		return ctx.adapter.listSpecs();
+	}),
+	listWithMeta: publicProcedure.query(async ({ ctx }) => {
+		return ctx.adapter.listSpecsWithMeta();
+	}),
+	get: publicProcedure.input(z.object({ id: z.string() })).query(async ({ ctx, input }) => {
+		return ctx.adapter.readSpec(input.id);
+	}),
+	getRaw: publicProcedure.input(z.object({ id: z.string() })).query(async ({ ctx, input }) => {
+		return ctx.adapter.readSpecRaw(input.id);
+	}),
+	save: publicProcedure.input(z.object({
+		id: z.string(),
+		content: z.string()
+	})).mutation(async ({ ctx, input }) => {
+		await ctx.adapter.writeSpec(input.id, input.content);
+		return { success: true };
+	}),
+	validate: publicProcedure.input(z.object({ id: z.string() })).query(async ({ ctx, input }) => {
+		return ctx.adapter.validateSpec(input.id);
+	}),
+	subscribe: publicProcedure.subscription(({ ctx }) => {
+		return createReactiveSubscription(() => ctx.adapter.listSpecsWithMeta());
+	}),
+	subscribeOne: publicProcedure.input(z.object({ id: z.string() })).subscription(({ ctx, input }) => {
+		return createReactiveSubscriptionWithInput((id) => ctx.adapter.readSpec(id))(input.id);
+	}),
+	subscribeRaw: publicProcedure.input(z.object({ id: z.string() })).subscription(({ ctx, input }) => {
+		return createReactiveSubscriptionWithInput((id) => ctx.adapter.readSpecRaw(id))(input.id);
+	})
+});
+/**
+* Change router - change proposal operations
+*/
+const changeRouter = router({
+	list: publicProcedure.query(async ({ ctx }) => {
+		return ctx.adapter.listChanges();
+	}),
+	listWithMeta: publicProcedure.query(async ({ ctx }) => {
+		return ctx.adapter.listChangesWithMeta();
+	}),
+	listArchived: publicProcedure.query(async ({ ctx }) => {
+		return ctx.adapter.listArchivedChanges();
+	}),
+	get: publicProcedure.input(z.object({ id: z.string() })).query(async ({ ctx, input }) => {
+		return ctx.adapter.readChange(input.id);
+	}),
+	getRaw: publicProcedure.input(z.object({ id: z.string() })).query(async ({ ctx, input }) => {
+		return ctx.adapter.readChangeRaw(input.id);
+	}),
+	save: publicProcedure.input(z.object({
+		id: z.string(),
+		proposal: z.string(),
+		tasks: z.string().optional()
+	})).mutation(async ({ ctx, input }) => {
+		await ctx.adapter.writeChange(input.id, input.proposal, input.tasks);
+		return { success: true };
+	}),
+	archive: publicProcedure.input(z.object({ id: z.string() })).mutation(async ({ ctx, input }) => {
+		return ctx.adapter.archiveChange(input.id);
+	}),
+	validate: publicProcedure.input(z.object({ id: z.string() })).query(async ({ ctx, input }) => {
+		return ctx.adapter.validateChange(input.id);
+	}),
+	toggleTask: publicProcedure.input(z.object({
+		changeId: z.string(),
+		taskIndex: z.number().int().positive(),
+		completed: z.boolean()
+	})).mutation(async ({ ctx, input }) => {
+		if (!await ctx.adapter.toggleTask(input.changeId, input.taskIndex, input.completed)) throw new Error(`Failed to toggle task ${input.taskIndex} in change ${input.changeId}`);
+		return { success: true };
+	}),
+	subscribe: publicProcedure.subscription(({ ctx }) => {
+		return createReactiveSubscription(() => ctx.adapter.listChangesWithMeta());
+	}),
+	subscribeOne: publicProcedure.input(z.object({ id: z.string() })).subscription(({ ctx, input }) => {
+		return createReactiveSubscriptionWithInput((id) => ctx.adapter.readChange(id))(input.id);
+	}),
+	subscribeFiles: publicProcedure.input(z.object({ id: z.string() })).subscription(({ ctx, input }) => {
+		return createReactiveSubscriptionWithInput((id) => ctx.adapter.readChangeFiles(id))(input.id);
+	}),
+	subscribeRaw: publicProcedure.input(z.object({ id: z.string() })).subscription(({ ctx, input }) => {
+		return createReactiveSubscriptionWithInput((id) => ctx.adapter.readChangeRaw(id))(input.id);
+	})
+});
+/**
+* Init router - project initialization
+*/
+const initRouter = router({ init: publicProcedure.mutation(async ({ ctx }) => {
+	await ctx.adapter.init();
+	return { success: true };
+}) });
+/**
+* Project router - project-level files (project.md, AGENTS.md)
+*/
+const projectRouter = router({
+	getProjectMd: publicProcedure.query(async ({ ctx }) => {
+		return ctx.adapter.readProjectMd();
+	}),
+	getAgentsMd: publicProcedure.query(async ({ ctx }) => {
+		return ctx.adapter.readAgentsMd();
+	}),
+	saveProjectMd: publicProcedure.input(z.object({ content: z.string() })).mutation(async ({ ctx, input }) => {
+		await ctx.adapter.writeProjectMd(input.content);
+		return { success: true };
+	}),
+	saveAgentsMd: publicProcedure.input(z.object({ content: z.string() })).mutation(async ({ ctx, input }) => {
+		await ctx.adapter.writeAgentsMd(input.content);
+		return { success: true };
+	}),
+	subscribeProjectMd: publicProcedure.subscription(({ ctx }) => {
+		return createReactiveSubscription(() => ctx.adapter.readProjectMd());
+	}),
+	subscribeAgentsMd: publicProcedure.subscription(({ ctx }) => {
+		return createReactiveSubscription(() => ctx.adapter.readAgentsMd());
+	})
+});
+/**
+* Archive router - archived changes
+*/
+const archiveRouter = router({
+	list: publicProcedure.query(async ({ ctx }) => {
+		return ctx.adapter.listArchivedChanges();
+	}),
+	listWithMeta: publicProcedure.query(async ({ ctx }) => {
+		return ctx.adapter.listArchivedChangesWithMeta();
+	}),
+	get: publicProcedure.input(z.object({ id: z.string() })).query(async ({ ctx, input }) => {
+		return ctx.adapter.readArchivedChange(input.id);
+	}),
+	getRaw: publicProcedure.input(z.object({ id: z.string() })).query(async ({ ctx, input }) => {
+		return ctx.adapter.readArchivedChangeRaw(input.id);
+	}),
+	subscribe: publicProcedure.subscription(({ ctx }) => {
+		return createReactiveSubscription(() => ctx.adapter.listArchivedChangesWithMeta());
+	}),
+	subscribeOne: publicProcedure.input(z.object({ id: z.string() })).subscription(({ ctx, input }) => {
+		return createReactiveSubscriptionWithInput((id) => ctx.adapter.readArchivedChange(id))(input.id);
+	}),
+	subscribeFiles: publicProcedure.input(z.object({ id: z.string() })).subscription(({ ctx, input }) => {
+		return createReactiveSubscriptionWithInput((id) => ctx.adapter.readArchivedChangeFiles(id))(input.id);
+	})
+});
+z.object({
+	type: z.enum([
+		"spec",
+		"change",
+		"archive",
+		"project"
+	]),
+	action: z.enum([
+		"create",
+		"update",
+		"delete"
+	]),
+	id: z.string().optional(),
+	path: z.string(),
+	timestamp: z.number()
+});
+/**
+* Realtime router - file change subscriptions
+*/
+const realtimeRouter = router({
+	onFileChange: publicProcedure.subscription(({ ctx }) => {
+		return observable((emit) => {
+			if (!ctx.watcher) {
+				emit.error(/* @__PURE__ */ new Error("File watcher not available"));
+				return () => {};
+			}
+			const handler = (event) => {
+				emit.next(event);
+			};
+			ctx.watcher.on("change", handler);
+			return () => {
+				ctx.watcher?.off("change", handler);
+			};
+		});
+	}),
+	onSpecChange: publicProcedure.input(z.object({ specId: z.string().optional() }).optional()).subscription(({ ctx, input }) => {
+		return observable((emit) => {
+			if (!ctx.watcher) {
+				emit.error(/* @__PURE__ */ new Error("File watcher not available"));
+				return () => {};
+			}
+			const handler = (event) => {
+				if (event.type !== "spec") return;
+				if (input?.specId && event.id !== input.specId) return;
+				emit.next(event);
+			};
+			ctx.watcher.on("change", handler);
+			return () => {
+				ctx.watcher?.off("change", handler);
+			};
+		});
+	}),
+	onChangeChange: publicProcedure.input(z.object({ changeId: z.string().optional() }).optional()).subscription(({ ctx, input }) => {
+		return observable((emit) => {
+			if (!ctx.watcher) {
+				emit.error(/* @__PURE__ */ new Error("File watcher not available"));
+				return () => {};
+			}
+			const handler = (event) => {
+				if (event.type !== "change" && event.type !== "archive") return;
+				if (input?.changeId && event.id !== input.changeId) return;
+				emit.next(event);
+			};
+			ctx.watcher.on("change", handler);
+			return () => {
+				ctx.watcher?.off("change", handler);
+			};
+		});
+	})
+});
+/**
+* Config router - configuration management
+*/
+const configRouter = router({
+	get: publicProcedure.query(async ({ ctx }) => {
+		return ctx.configManager.readConfig();
+	}),
+	getEffectiveCliCommand: publicProcedure.query(async ({ ctx }) => {
+		return ctx.configManager.getCliCommandString();
+	}),
+	getDefaultCliCommand: publicProcedure.query(async () => {
+		return getDefaultCliCommandString();
+	}),
+	update: publicProcedure.input(z.object({
+		cli: z.object({ command: z.string() }).optional(),
+		ui: z.object({ theme: z.enum([
+			"light",
+			"dark",
+			"system"
+		]) }).optional()
+	})).mutation(async ({ ctx, input }) => {
+		await ctx.configManager.writeConfig(input);
+		return { success: true };
+	}),
+	setCliCommand: publicProcedure.input(z.object({ command: z.string() })).mutation(async ({ ctx, input }) => {
+		await ctx.configManager.setCliCommand(input.command);
+		return { success: true };
+	}),
+	subscribe: publicProcedure.subscription(({ ctx }) => {
+		return createReactiveSubscription(() => ctx.configManager.readConfig());
+	})
+});
+/**
+* CLI router - execute external openspec CLI commands
+*/
+const cliRouter = router({
+	checkAvailability: publicProcedure.query(async ({ ctx }) => {
+		return ctx.cliExecutor.checkAvailability();
+	}),
+	sniffGlobalCli: publicProcedure.query(async () => {
+		return sniffGlobalCli();
+	}),
+	installGlobalCliStream: publicProcedure.subscription(({ ctx }) => {
+		return observable((emit) => {
+			const cancel = ctx.cliExecutor.executeCommandStream([
+				"npm",
+				"install",
+				"-g",
+				"@fission-ai/openspec"
+			], (event) => {
+				emit.next(event);
+				if (event.type === "exit") emit.complete();
+			});
+			return () => {
+				cancel();
+			};
+		});
+	}),
+	runCommandStream: publicProcedure.input(z.object({
+		command: z.string(),
+		args: z.array(z.string()).default([])
+	})).subscription(({ ctx, input }) => {
+		return createCliStreamObservable(async (onEvent) => ctx.cliExecutor.executeCommandStream([input.command, ...input.args], onEvent));
+	}),
+	getAvailableTools: publicProcedure.query(() => {
+		return getAvailableTools().map((tool) => ({
+			name: tool.name,
+			value: tool.value,
+			available: tool.available,
+			successLabel: tool.successLabel
+		}));
+	}),
+	getAllTools: publicProcedure.query(() => {
+		return getAllTools().map((tool) => ({
+			name: tool.name,
+			value: tool.value,
+			available: tool.available,
+			successLabel: tool.successLabel
+		}));
+	}),
+	getConfiguredTools: publicProcedure.query(async ({ ctx }) => {
+		return getConfiguredTools(ctx.projectDir);
+	}),
+	subscribeConfiguredTools: publicProcedure.subscription(({ ctx }) => {
+		return createReactiveSubscription(() => getConfiguredTools(ctx.projectDir));
+	}),
+	init: publicProcedure.input(z.object({ tools: z.union([
+		z.array(z.string()),
+		z.literal("all"),
+		z.literal("none")
+	]).optional() }).optional()).mutation(async ({ ctx, input }) => {
+		return ctx.cliExecutor.init(input?.tools ?? "all");
+	}),
+	archive: publicProcedure.input(z.object({
+		changeId: z.string(),
+		skipSpecs: z.boolean().optional(),
+		noValidate: z.boolean().optional()
+	})).mutation(async ({ ctx, input }) => {
+		return ctx.cliExecutor.archive(input.changeId, {
+			skipSpecs: input.skipSpecs,
+			noValidate: input.noValidate
+		});
+	}),
+	validate: publicProcedure.input(z.object({
+		type: z.enum(["spec", "change"]).optional(),
+		id: z.string().optional()
+	})).mutation(async ({ ctx, input }) => {
+		return ctx.cliExecutor.validate(input.type, input.id);
+	}),
+	validateStream: publicProcedure.input(z.object({
+		type: z.enum(["spec", "change"]).optional(),
+		id: z.string().optional()
+	})).subscription(({ ctx, input }) => {
+		return createCliStreamObservable((onEvent) => ctx.cliExecutor.validateStream(input.type, input.id, onEvent));
+	}),
+	execute: publicProcedure.input(z.object({ args: z.array(z.string()) })).mutation(async ({ ctx, input }) => {
+		return ctx.cliExecutor.execute(input.args);
+	}),
+	initStream: publicProcedure.input(z.object({ tools: z.union([
+		z.array(z.string()),
+		z.literal("all"),
+		z.literal("none")
+	]).optional() }).optional()).subscription(({ ctx, input }) => {
+		return createCliStreamObservable((onEvent) => ctx.cliExecutor.initStream(input?.tools ?? "all", onEvent));
+	}),
+	archiveStream: publicProcedure.input(z.object({
+		changeId: z.string(),
+		skipSpecs: z.boolean().optional(),
+		noValidate: z.boolean().optional()
+	})).subscription(({ ctx, input }) => {
+		return createCliStreamObservable((onEvent) => ctx.cliExecutor.archiveStream(input.changeId, {
+			skipSpecs: input.skipSpecs,
+			noValidate: input.noValidate
+		}, onEvent));
+	})
+});
+/**
+* Main app router
+*/
+const appRouter = router({
+	dashboard: dashboardRouter,
+	spec: specRouter,
+	change: changeRouter,
+	archive: archiveRouter,
+	project: projectRouter,
+	init: initRouter,
+	realtime: realtimeRouter,
+	config: configRouter,
+	cli: cliRouter
+});
+
+//#endregion
+//#region src/port-utils.ts
+/**
+* Check if a port is available by trying to listen on it.
+* Uses default binding (both IPv4 and IPv6) to detect conflicts.
+*/
+function isPortAvailable(port) {
+	return new Promise((resolve) => {
+		const server = createServer$1();
+		server.once("error", () => {
+			resolve(false);
+		});
+		server.once("listening", () => {
+			server.close(() => resolve(true));
+		});
+		server.listen(port);
+	});
+}
+/**
+* Find an available port starting from the given port.
+* Will try up to maxAttempts ports sequentially.
+*
+* @param startPort - The preferred port to start checking from
+* @param maxAttempts - Maximum number of ports to try (default: 10)
+* @returns The first available port found
+* @throws Error if no available port is found in the range
+*/
+async function findAvailablePort(startPort, maxAttempts = 10) {
+	for (let i = 0; i < maxAttempts; i++) {
+		const port = startPort + i;
+		if (await isPortAvailable(port)) return port;
+	}
+	throw new Error(`No available port found in range ${startPort}-${startPort + maxAttempts - 1}`);
+}
+
+//#endregion
+//#region src/server.ts
+/**
+* OpenSpecUI HTTP/WebSocket server.
+*
+* Provides tRPC endpoints for:
+* - Dashboard data and project status
+* - Spec CRUD operations
+* - Change proposal management
+* - AI-assisted operations (review, translate, suggest)
+* - Realtime file change subscriptions via WebSocket
+*
+* @module server
+*/
+/**
+* Create an OpenSpecUI HTTP server with optional WebSocket support
+*/
+function createServer(config) {
+	const adapter = new OpenSpecAdapter(config.projectDir);
+	const configManager = new ConfigManager(config.projectDir);
+	const cliExecutor = new CliExecutor(configManager, config.projectDir);
+	const watcher = config.enableWatcher !== false ? new OpenSpecWatcher(config.projectDir) : void 0;
+	const app = new Hono();
+	const corsOrigins = config.corsOrigins ?? ["http://localhost:5173", "http://localhost:3000"];
+	app.use("*", cors({
+		origin: corsOrigins,
+		credentials: true
+	}));
+	app.get("/api/health", (c) => {
+		return c.json({
+			status: "ok",
+			projectDir: config.projectDir,
+			watcherEnabled: !!watcher
+		});
+	});
+	app.use("/trpc/*", async (c) => {
+		return await fetchRequestHandler({
+			endpoint: "/trpc",
+			req: c.req.raw,
+			router: appRouter,
+			createContext: () => ({
+				adapter,
+				configManager,
+				cliExecutor,
+				watcher,
+				projectDir: config.projectDir
+			})
+		});
+	});
+	const createContext = () => ({
+		adapter,
+		configManager,
+		cliExecutor,
+		watcher,
+		projectDir: config.projectDir
+	});
+	return {
+		app,
+		adapter,
+		configManager,
+		cliExecutor,
+		watcher,
+		createContext,
+		port: config.port ?? 3100
+	};
+}
+/**
+* Create WebSocket server for tRPC subscriptions
+*/
+async function createWebSocketServer(server, httpServer, config) {
+	await initWatcherPool(config.projectDir);
+	const wss = new WebSocketServer({ noServer: true });
+	const handler = applyWSSHandler({
+		wss,
+		router: appRouter,
+		createContext: server.createContext
+	});
+	httpServer.on("upgrade", (...args) => {
+		const [request, socket, head] = args;
+		if (request.url?.startsWith("/trpc")) wss.handleUpgrade(request, socket, head, (ws) => {
+			wss.emit("connection", ws, request);
+		});
+	});
+	server.watcher?.start();
+	return {
+		wss,
+		handler,
+		close: () => {
+			handler.broadcastReconnectNotification();
+			wss.close();
+			server.watcher?.stop();
+		}
+	};
+}
+/**
+* Start the OpenSpec UI server with WebSocket support.
+* Automatically finds an available port if the preferred port is occupied.
+*
+* @param config - Server configuration
+* @param setupApp - Optional callback to configure the Hono app before starting (e.g., add static file middleware)
+* @returns Running server instance with actual port and close function
+*/
+async function startServer(config, setupApp) {
+	const preferredPort = config.port ?? 3100;
+	const port = await findAvailablePort(preferredPort);
+	const server = createServer({
+		...config,
+		port
+	});
+	if (setupApp) setupApp(server.app);
+	const httpServer = serve({
+		fetch: server.app.fetch,
+		port
+	});
+	const wsServer = await createWebSocketServer(server, httpServer, { projectDir: config.projectDir });
+	return {
+		url: `http://localhost:${port}`,
+		port,
+		preferredPort,
+		close: async () => {
+			wsServer.close();
+			httpServer.close();
+		}
+	};
+}
+
+//#endregion
+export { createServer, createWebSocketServer, findAvailablePort, isPortAvailable, startServer };

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@openspecui/server",
+  "version": "0.9.0",
+  "type": "module",
+  "main": "dist/index.mjs",
+  "exports": {
+    ".": {
+      "import": "./dist/index.mjs"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@hono/node-server": "^1.14.1",
+    "@trpc/server": "^11.0.0",
+    "hono": "^4.7.3",
+    "ws": "^8.18.0",
+    "yargs": "^18.0.0",
+    "zod": "^3.24.1",
+    "@openspecui/core": "0.9.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.10.2",
+    "@types/ws": "^8.5.13",
+    "@types/yargs": "^17.0.35",
+    "tsdown": "^0.16.6",
+    "tsx": "^4.19.2",
+    "typescript": "^5.7.2",
+    "vitest": "^2.1.8"
+  },
+  "scripts": {
+    "build": "tsdown src/index.ts --format esm --no-dts",
+    "typecheck": "tsc --noEmit -p tsconfig.check.json",
+    "dev": "tsx watch src/standalone.ts",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  }
+}