@nextclaw/server 0.3.4

package/dist/index.d.ts

@@ -0,0 +1,145 @@
+import { Hono } from 'hono';
+import { Config } from '@nextclaw/core';
+
+type ApiError = {
+    code: string;
+    message: string;
+    details?: Record<string, unknown>;
+};
+type ApiResponse<T> = {
+    ok: true;
+    data: T;
+} | {
+    ok: false;
+    error: ApiError;
+};
+type ProviderConfigView = {
+    apiKeySet: boolean;
+    apiKeyMasked?: string;
+    apiBase?: string | null;
+    extraHeaders?: Record<string, string> | null;
+    wireApi?: "auto" | "chat" | "responses" | null;
+};
+type ProviderConfigUpdate = {
+    apiKey?: string | null;
+    apiBase?: string | null;
+    extraHeaders?: Record<string, string> | null;
+    wireApi?: "auto" | "chat" | "responses" | null;
+};
+type ConfigView = {
+    agents: {
+        defaults: {
+            model: string;
+            workspace?: string;
+            maxTokens?: number;
+            temperature?: number;
+            maxToolIterations?: number;
+        };
+        context?: {
+            bootstrap?: {
+                files?: string[];
+                minimalFiles?: string[];
+                heartbeatFiles?: string[];
+                perFileChars?: number;
+                totalChars?: number;
+            };
+            memory?: {
+                enabled?: boolean;
+                maxChars?: number;
+            };
+        };
+    };
+    providers: Record<string, ProviderConfigView>;
+    channels: Record<string, Record<string, unknown>>;
+    tools?: Record<string, unknown>;
+    gateway?: Record<string, unknown>;
+    ui?: Record<string, unknown>;
+    plugins?: Record<string, unknown>;
+};
+type ProviderSpecView = {
+    name: string;
+    displayName?: string;
+    keywords: string[];
+    envKey: string;
+    isGateway?: boolean;
+    isLocal?: boolean;
+    defaultApiBase?: string;
+    supportsWireApi?: boolean;
+    wireApiOptions?: Array<"auto" | "chat" | "responses">;
+    defaultWireApi?: "auto" | "chat" | "responses";
+};
+type ChannelSpecView = {
+    name: string;
+    displayName?: string;
+    enabled: boolean;
+    tutorialUrl?: string;
+};
+type ConfigMetaView = {
+    providers: ProviderSpecView[];
+    channels: ChannelSpecView[];
+};
+type ConfigUiHint = {
+    label?: string;
+    help?: string;
+    group?: string;
+    order?: number;
+    advanced?: boolean;
+    sensitive?: boolean;
+    placeholder?: string;
+};
+type ConfigUiHints = Record<string, ConfigUiHint>;
+type ConfigSchemaResponse = {
+    schema: Record<string, unknown>;
+    uiHints: ConfigUiHints;
+    version: string;
+    generatedAt: string;
+};
+type UiServerEvent = {
+    type: "config.updated";
+    payload: {
+        path: string;
+    };
+} | {
+    type: "config.reload.started";
+    payload?: Record<string, unknown>;
+} | {
+    type: "config.reload.finished";
+    payload?: Record<string, unknown>;
+} | {
+    type: "error";
+    payload: {
+        message: string;
+        code?: string;
+    };
+};
+type UiServerOptions = {
+    host: string;
+    port: number;
+    configPath: string;
+    corsOrigins?: string[] | "*";
+    staticDir?: string;
+};
+type UiServerHandle = {
+    host: string;
+    port: number;
+    close: () => Promise<void>;
+    publish: (event: UiServerEvent) => void;
+};
+
+declare function startUiServer(options: UiServerOptions): UiServerHandle;
+
+type UiRouterOptions = {
+    configPath: string;
+    publish: (event: UiServerEvent) => void;
+};
+declare function createUiRouter(options: UiRouterOptions): Hono;
+
+declare function buildConfigView(config: Config): ConfigView;
+declare function buildConfigMeta(config: Config): ConfigMetaView;
+declare function buildConfigSchemaView(config: Config): ConfigSchemaResponse;
+declare function loadConfigOrDefault(configPath: string): Config;
+declare function updateModel(configPath: string, model: string): ConfigView;
+declare function updateProvider(configPath: string, providerName: string, patch: ProviderConfigUpdate): ProviderConfigView | null;
+declare function updateChannel(configPath: string, channelName: string, patch: Record<string, unknown>): Record<string, unknown> | null;
+
+export { type ApiError, type ApiResponse, type ChannelSpecView, type ConfigMetaView, type ConfigSchemaResponse, type ConfigUiHint, type ConfigUiHints, type ConfigView, type ProviderConfigUpdate, type ProviderConfigView, type ProviderSpecView, type UiServerEvent, type UiServerHandle, type UiServerOptions, buildConfigMeta, buildConfigSchemaView, buildConfigView, createUiRouter, loadConfigOrDefault, startUiServer, updateChannel, updateModel, updateProvider };

package/dist/index.js

@@ -0,0 +1,323 @@
+// src/ui/server.ts
+import { Hono as Hono2 } from "hono";
+import { cors } from "hono/cors";
+import { serve } from "@hono/node-server";
+import { WebSocketServer, WebSocket } from "ws";
+import { existsSync, readFileSync } from "fs";
+import { readFile, stat } from "fs/promises";
+import { join } from "path";
+
+// src/ui/router.ts
+import { Hono } from "hono";
+
+// src/ui/config.ts
+import {
+  loadConfig,
+  saveConfig,
+  ConfigSchema,
+  PROVIDERS,
+  buildConfigSchema,
+  findProviderByName,
+  getPackageVersion,
+  getWorkspacePathFromConfig
+} from "@nextclaw/core";
+import { loadPluginUiMetadata } from "@nextclaw/openclaw-compat";
+var MASK_MIN_LENGTH = 8;
+function maskApiKey(value) {
+  if (!value) {
+    return { apiKeySet: false };
+  }
+  if (value.length < MASK_MIN_LENGTH) {
+    return { apiKeySet: true, apiKeyMasked: "****" };
+  }
+  return {
+    apiKeySet: true,
+    apiKeyMasked: `${value.slice(0, 2)}****${value.slice(-4)}`
+  };
+}
+function toProviderView(provider, spec) {
+  const masked = maskApiKey(provider.apiKey);
+  const view = {
+    apiKeySet: masked.apiKeySet,
+    apiKeyMasked: masked.apiKeyMasked,
+    apiBase: provider.apiBase ?? null,
+    extraHeaders: provider.extraHeaders ?? null
+  };
+  if (spec?.supportsWireApi) {
+    view.wireApi = provider.wireApi ?? spec.defaultWireApi ?? "auto";
+  }
+  return view;
+}
+function buildConfigView(config) {
+  const providers = {};
+  for (const [name, provider] of Object.entries(config.providers)) {
+    const spec = findProviderByName(name);
+    providers[name] = toProviderView(provider, spec);
+  }
+  return {
+    agents: config.agents,
+    providers,
+    channels: config.channels,
+    tools: config.tools,
+    gateway: config.gateway,
+    ui: config.ui,
+    plugins: config.plugins
+  };
+}
+function buildConfigMeta(config) {
+  const providers = PROVIDERS.map((spec) => ({
+    name: spec.name,
+    displayName: spec.displayName,
+    keywords: spec.keywords,
+    envKey: spec.envKey,
+    isGateway: spec.isGateway,
+    isLocal: spec.isLocal,
+    defaultApiBase: spec.defaultApiBase,
+    supportsWireApi: spec.supportsWireApi,
+    wireApiOptions: spec.wireApiOptions,
+    defaultWireApi: spec.defaultWireApi
+  }));
+  const channels = Object.keys(config.channels).map((name) => ({
+    name,
+    displayName: name,
+    enabled: Boolean(config.channels[name]?.enabled)
+  }));
+  return { providers, channels };
+}
+function buildConfigSchemaView(config) {
+  const workspaceDir = getWorkspacePathFromConfig(config);
+  const plugins = loadPluginUiMetadata({ config, workspaceDir });
+  return buildConfigSchema({ version: getPackageVersion(), plugins });
+}
+function loadConfigOrDefault(configPath) {
+  return loadConfig(configPath);
+}
+function updateModel(configPath, model) {
+  const config = loadConfigOrDefault(configPath);
+  config.agents.defaults.model = model;
+  const next = ConfigSchema.parse(config);
+  saveConfig(next, configPath);
+  return buildConfigView(next);
+}
+function updateProvider(configPath, providerName, patch) {
+  const config = loadConfigOrDefault(configPath);
+  const provider = config.providers[providerName];
+  if (!provider) {
+    return null;
+  }
+  const spec = findProviderByName(providerName);
+  if (Object.prototype.hasOwnProperty.call(patch, "apiKey")) {
+    provider.apiKey = patch.apiKey ?? "";
+  }
+  if (Object.prototype.hasOwnProperty.call(patch, "apiBase")) {
+    provider.apiBase = patch.apiBase ?? null;
+  }
+  if (Object.prototype.hasOwnProperty.call(patch, "extraHeaders")) {
+    provider.extraHeaders = patch.extraHeaders ?? null;
+  }
+  if (Object.prototype.hasOwnProperty.call(patch, "wireApi") && spec?.supportsWireApi) {
+    provider.wireApi = patch.wireApi ?? spec.defaultWireApi ?? "auto";
+  }
+  const next = ConfigSchema.parse(config);
+  saveConfig(next, configPath);
+  const updated = next.providers[providerName];
+  return toProviderView(updated, spec ?? void 0);
+}
+function updateChannel(configPath, channelName, patch) {
+  const config = loadConfigOrDefault(configPath);
+  const channel = config.channels[channelName];
+  if (!channel) {
+    return null;
+  }
+  config.channels[channelName] = { ...channel, ...patch };
+  const next = ConfigSchema.parse(config);
+  saveConfig(next, configPath);
+  return next.channels[channelName];
+}
+
+// src/ui/router.ts
+import { probeFeishu } from "@nextclaw/core";
+function ok(data) {
+  return { ok: true, data };
+}
+function err(code, message, details) {
+  return { ok: false, error: { code, message, details } };
+}
+async function readJson(req) {
+  try {
+    const data = await req.json();
+    return { ok: true, data };
+  } catch {
+    return { ok: false };
+  }
+}
+function createUiRouter(options) {
+  const app = new Hono();
+  app.notFound((c) => c.json(err("NOT_FOUND", "endpoint not found"), 404));
+  app.get("/api/health", (c) => c.json(ok({ status: "ok" })));
+  app.get("/api/config", (c) => {
+    const config = loadConfigOrDefault(options.configPath);
+    return c.json(ok(buildConfigView(config)));
+  });
+  app.get("/api/config/meta", (c) => {
+    const config = loadConfigOrDefault(options.configPath);
+    return c.json(ok(buildConfigMeta(config)));
+  });
+  app.get("/api/config/schema", (c) => {
+    const config = loadConfigOrDefault(options.configPath);
+    return c.json(ok(buildConfigSchemaView(config)));
+  });
+  app.put("/api/config/model", async (c) => {
+    const body = await readJson(c.req.raw);
+    if (!body.ok || !body.data.model) {
+      return c.json(err("INVALID_BODY", "model is required"), 400);
+    }
+    const view = updateModel(options.configPath, body.data.model);
+    options.publish({ type: "config.updated", payload: { path: "agents.defaults.model" } });
+    return c.json(ok({ model: view.agents.defaults.model }));
+  });
+  app.put("/api/config/providers/:provider", async (c) => {
+    const provider = c.req.param("provider");
+    const body = await readJson(c.req.raw);
+    if (!body.ok) {
+      return c.json(err("INVALID_BODY", "invalid json body"), 400);
+    }
+    const result = updateProvider(options.configPath, provider, body.data);
+    if (!result) {
+      return c.json(err("NOT_FOUND", `unknown provider: ${provider}`), 404);
+    }
+    options.publish({ type: "config.updated", payload: { path: `providers.${provider}` } });
+    return c.json(ok(result));
+  });
+  app.put("/api/config/channels/:channel", async (c) => {
+    const channel = c.req.param("channel");
+    const body = await readJson(c.req.raw);
+    if (!body.ok) {
+      return c.json(err("INVALID_BODY", "invalid json body"), 400);
+    }
+    const result = updateChannel(options.configPath, channel, body.data);
+    if (!result) {
+      return c.json(err("NOT_FOUND", `unknown channel: ${channel}`), 404);
+    }
+    options.publish({ type: "config.updated", payload: { path: `channels.${channel}` } });
+    return c.json(ok(result));
+  });
+  app.post("/api/channels/feishu/probe", async (c) => {
+    const config = loadConfigOrDefault(options.configPath);
+    const feishu = config.channels.feishu;
+    if (!feishu?.appId || !feishu?.appSecret) {
+      return c.json(err("MISSING_CREDENTIALS", "Feishu appId/appSecret not configured"), 400);
+    }
+    const result = await probeFeishu(String(feishu.appId), String(feishu.appSecret));
+    if (!result.ok) {
+      return c.json(err("PROBE_FAILED", result.error), 400);
+    }
+    return c.json(
+      ok({
+        appId: result.appId,
+        botName: result.botName ?? null,
+        botOpenId: result.botOpenId ?? null
+      })
+    );
+  });
+  return app;
+}
+
+// src/ui/server.ts
+import { serveStatic } from "hono/serve-static";
+var DEFAULT_CORS_ORIGINS = (origin) => {
+  if (!origin) {
+    return void 0;
+  }
+  if (origin.startsWith("http://localhost:") || origin.startsWith("http://127.0.0.1:")) {
+    return origin;
+  }
+  return void 0;
+};
+function startUiServer(options) {
+  const app = new Hono2();
+  const origin = options.corsOrigins ?? DEFAULT_CORS_ORIGINS;
+  app.use("/api/*", cors({ origin }));
+  const clients = /* @__PURE__ */ new Set();
+  const publish = (event) => {
+    const payload = JSON.stringify(event);
+    for (const client of clients) {
+      if (client.readyState === WebSocket.OPEN) {
+        client.send(payload);
+      }
+    }
+  };
+  app.route(
+    "/",
+    createUiRouter({
+      configPath: options.configPath,
+      publish
+    })
+  );
+  const staticDir = options.staticDir;
+  if (staticDir && existsSync(join(staticDir, "index.html"))) {
+    const indexHtml = readFileSync(join(staticDir, "index.html"), "utf-8");
+    app.use(
+      "/*",
+      serveStatic({
+        root: staticDir,
+        join,
+        getContent: async (path) => {
+          try {
+            return await readFile(path);
+          } catch {
+            return null;
+          }
+        },
+        isDir: async (path) => {
+          try {
+            return (await stat(path)).isDirectory();
+          } catch {
+            return false;
+          }
+        }
+      })
+    );
+    app.get("*", (c) => {
+      const path = c.req.path;
+      if (path.startsWith("/api") || path.startsWith("/ws")) {
+        return c.notFound();
+      }
+      return c.html(indexHtml);
+    });
+  }
+  const server = serve({
+    fetch: app.fetch,
+    port: options.port,
+    hostname: options.host
+  });
+  const wss = new WebSocketServer({
+    server,
+    path: "/ws"
+  });
+  wss.on("connection", (socket) => {
+    clients.add(socket);
+    socket.on("close", () => clients.delete(socket));
+  });
+  return {
+    host: options.host,
+    port: options.port,
+    publish,
+    close: () => new Promise((resolve) => {
+      wss.close(() => {
+        server.close(() => resolve());
+      });
+    })
+  };
+}
+export {
+  buildConfigMeta,
+  buildConfigSchemaView,
+  buildConfigView,
+  createUiRouter,
+  loadConfigOrDefault,
+  startUiServer,
+  updateChannel,
+  updateModel,
+  updateProvider
+};

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@nextclaw/server",
+  "version": "0.3.4",
+  "private": false,
+  "description": "Nextclaw UI/API server.",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@hono/node-server": "^1.13.3",
+    "hono": "^4.6.2",
+    "ws": "^8.18.0",
+    "@nextclaw/core": "^0.4.8",
+    "@nextclaw/openclaw-compat": "^0.1.1"
+  },
+  "devDependencies": {
+    "@types/node": "^20.17.6",
+    "@types/ws": "^8.5.14",
+    "@typescript-eslint/eslint-plugin": "^7.18.0",
+    "@typescript-eslint/parser": "^7.18.0",
+    "eslint": "^8.57.1",
+    "eslint-config-prettier": "^9.1.0",
+    "prettier": "^3.3.3",
+    "tsup": "^8.3.5",
+    "tsx": "^4.19.2",
+    "typescript": "^5.6.3",
+    "vitest": "^2.1.2"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --dts --out-dir dist",
+    "lint": "eslint .",
+    "tsc": "tsc -p tsconfig.json",
+    "test": "vitest"
+  }
+}