nextclaw-server 0.2.8

package/dist/index.d.ts

@@ -0,0 +1,118 @@
+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;
+};
+type ProviderConfigUpdate = {
+    apiKey?: string | null;
+    apiBase?: string | null;
+    extraHeaders?: Record<string, string> | null;
+};
+type UiConfigView = {
+    enabled: boolean;
+    host: string;
+    port: number;
+    open: boolean;
+};
+type ConfigView = {
+    agents: {
+        defaults: {
+            model: string;
+            workspace?: string;
+            maxTokens?: number;
+            temperature?: number;
+            maxToolIterations?: number;
+        };
+    };
+    providers: Record<string, ProviderConfigView>;
+    channels: Record<string, Record<string, unknown>>;
+    tools?: Record<string, unknown>;
+    gateway?: Record<string, unknown>;
+    ui?: UiConfigView;
+};
+type ProviderSpecView = {
+    name: string;
+    displayName?: string;
+    keywords: string[];
+    envKey: string;
+    isGateway?: boolean;
+    isLocal?: boolean;
+    defaultApiBase?: string;
+};
+type ChannelSpecView = {
+    name: string;
+    displayName?: string;
+    enabled: boolean;
+    tutorialUrl?: string;
+};
+type ConfigMetaView = {
+    providers: ProviderSpecView[];
+    channels: ChannelSpecView[];
+};
+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;
+    onReload?: () => Promise<void> | void;
+    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;
+    onReload?: () => Promise<void> | void;
+};
+declare function createUiRouter(options: UiRouterOptions): Hono;
+
+declare function buildConfigView(config: Config): ConfigView;
+declare function buildConfigMeta(config: Config): ConfigMetaView;
+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;
+declare function updateUi(configPath: string, patch: Record<string, unknown>): Record<string, unknown>;
+
+export { type ApiError, type ApiResponse, type ChannelSpecView, type ConfigMetaView, type ConfigView, type ProviderConfigUpdate, type ProviderConfigView, type ProviderSpecView, type UiConfigView, type UiServerEvent, type UiServerHandle, type UiServerOptions, buildConfigMeta, buildConfigView, createUiRouter, loadConfigOrDefault, startUiServer, updateChannel, updateModel, updateProvider, updateUi };

package/dist/index.js

@@ -0,0 +1,322 @@
+// 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 } from "nextclaw-core";
+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) {
+  const masked = maskApiKey(provider.apiKey);
+  return {
+    apiKeySet: masked.apiKeySet,
+    apiKeyMasked: masked.apiKeyMasked,
+    apiBase: provider.apiBase ?? null,
+    extraHeaders: provider.extraHeaders ?? null
+  };
+}
+function buildConfigView(config) {
+  const providers = {};
+  for (const [name, provider] of Object.entries(config.providers)) {
+    providers[name] = toProviderView(provider);
+  }
+  return {
+    agents: config.agents,
+    providers,
+    channels: config.channels,
+    tools: config.tools,
+    gateway: config.gateway,
+    ui: config.ui
+  };
+}
+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
+  }));
+  const channels = Object.keys(config.channels).map((name) => ({
+    name,
+    displayName: name,
+    enabled: Boolean(config.channels[name]?.enabled)
+  }));
+  return { providers, channels };
+}
+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;
+  }
+  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;
+  }
+  const next = ConfigSchema.parse(config);
+  saveConfig(next, configPath);
+  const updated = next.providers[providerName];
+  return toProviderView(updated);
+}
+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];
+}
+function updateUi(configPath, patch) {
+  const config = loadConfigOrDefault(configPath);
+  config.ui = { ...config.ui, ...patch };
+  const next = ConfigSchema.parse(config);
+  saveConfig(next, configPath);
+  return next.ui;
+}
+
+// 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.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
+      })
+    );
+  });
+  app.put("/api/config/ui", async (c) => {
+    const body = await readJson(c.req.raw);
+    if (!body.ok) {
+      return c.json(err("INVALID_BODY", "invalid json body"), 400);
+    }
+    const result = updateUi(options.configPath, body.data);
+    options.publish({ type: "config.updated", payload: { path: "ui" } });
+    return c.json(ok(result));
+  });
+  app.post("/api/config/reload", async (c) => {
+    options.publish({ type: "config.reload.started" });
+    try {
+      await options.onReload?.();
+    } catch (error) {
+      options.publish({
+        type: "error",
+        payload: { message: "reload failed", code: "RELOAD_FAILED" }
+      });
+      return c.json(err("RELOAD_FAILED", "reload failed"), 500);
+    }
+    options.publish({ type: "config.reload.finished" });
+    return c.json(ok({ status: "ok" }));
+  });
+  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,
+      onReload: options.onReload
+    })
+  );
+  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,
+  buildConfigView,
+  createUiRouter,
+  loadConfigOrDefault,
+  startUiServer,
+  updateChannel,
+  updateModel,
+  updateProvider,
+  updateUi
+};

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "nextclaw-server",
+  "version": "0.2.8",
+  "private": false,
+  "description": "Nextclaw UI/API server.",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --dts --out-dir dist",
+    "lint": "eslint .",
+    "tsc": "tsc -p tsconfig.json",
+    "test": "vitest"
+  },
+  "dependencies": {
+    "@hono/node-server": "^1.13.3",
+    "hono": "^4.6.2",
+    "nextclaw-core": "workspace:*",
+    "ws": "^8.18.0"
+  },
+  "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"
+  }
+}