nolo-cli 0.1.23 → 0.1.29

package/server/providerHealthProbe.ts

@@ -0,0 +1,198 @@
+export type ProviderHealthProbeTarget = {
+  provider: string;
+  model: string;
+  endpoint: string;
+  envKey: string;
+};
+
+export type ProviderHealthProbeAttempt = {
+  ok: boolean;
+  status?: number;
+  latencyMs: number;
+  message: string;
+  rateLimitHeaders: Record<string, string>;
+};
+
+export type ProviderHealthProbeResult = ProviderHealthProbeTarget & {
+  keyConfigured: boolean;
+  attempts: ProviderHealthProbeAttempt[];
+  summary: {
+    total: number;
+    successes: number;
+    successRate: number;
+    avgLatencyMs: number | null;
+    maxLatencyMs: number | null;
+    statusCounts: Record<string, number>;
+    lastError: string | null;
+  };
+};
+
+const DEFAULT_TIMEOUT_MS = 20_000;
+
+export const DEFAULT_PROVIDER_HEALTH_TARGETS: ProviderHealthProbeTarget[] = [
+  {
+    provider: "fireworks",
+    model: "accounts/fireworks/models/kimi-k2p6",
+    endpoint: "https://api.fireworks.ai/inference/v1/chat/completions",
+    envKey: "FIREWORKS_API_KEY",
+  },
+  {
+    provider: "deepinfra",
+    model: "moonshotai/Kimi-K2.6",
+    endpoint: "https://api.deepinfra.com/v1/openai/chat/completions",
+    envKey: "DEEPINFRA_API_KEY",
+  },
+  {
+    provider: "openrouter",
+    model: "moonshotai/kimi-k2.6",
+    endpoint: "https://openrouter.ai/api/v1/chat/completions",
+    envKey: "OPENROUTER_API_KEY",
+  },
+];
+
+const RATE_LIMIT_HEADER_NAMES = [
+  "x-ratelimit-limit",
+  "x-ratelimit-remaining",
+  "x-ratelimit-reset",
+  "x-ratelimit-limit-requests",
+  "x-ratelimit-remaining-requests",
+  "x-ratelimit-reset-requests",
+  "x-ratelimit-limit-tokens",
+  "x-ratelimit-remaining-tokens",
+  "x-ratelimit-reset-tokens",
+  "retry-after",
+];
+
+function clampAttempts(value: number | undefined) {
+  if (!Number.isFinite(value ?? NaN)) return 2;
+  return Math.max(1, Math.min(10, Math.floor(value as number)));
+}
+
+function extractMessage(text: string) {
+  try {
+    const parsed = JSON.parse(text);
+    return String(
+      parsed?.error?.message ??
+        parsed?.choices?.[0]?.message?.content ??
+        parsed?.choices?.[0]?.message?.reasoning_content ??
+        text
+    ).slice(0, 500);
+  } catch {
+    return text.slice(0, 500);
+  }
+}
+
+function collectRateLimitHeaders(headers: Headers) {
+  const result: Record<string, string> = {};
+  for (const name of RATE_LIMIT_HEADER_NAMES) {
+    const value = headers.get(name);
+    if (value) result[name] = value;
+  }
+  return result;
+}
+
+function summarizeAttempts(attempts: ProviderHealthProbeAttempt[]) {
+  const successes = attempts.filter((item) => item.ok).length;
+  const latencies = attempts.map((item) => item.latencyMs);
+  const statusCounts: Record<string, number> = {};
+  let lastError: string | null = null;
+
+  for (const attempt of attempts) {
+    const key = String(attempt.status ?? "transport_error");
+    statusCounts[key] = (statusCounts[key] ?? 0) + 1;
+    if (!attempt.ok) lastError = attempt.message;
+  }
+
+  return {
+    total: attempts.length,
+    successes,
+    successRate: attempts.length ? successes / attempts.length : 0,
+    avgLatencyMs: latencies.length
+      ? Math.round(latencies.reduce((sum, item) => sum + item, 0) / latencies.length)
+      : null,
+    maxLatencyMs: latencies.length ? Math.max(...latencies) : null,
+    statusCounts,
+    lastError,
+  };
+}
+
+async function probeOnce(args: {
+  target: ProviderHealthProbeTarget;
+  apiKey: string;
+  fetchImpl: typeof fetch;
+  timeoutMs: number;
+}): Promise<ProviderHealthProbeAttempt> {
+  const startedAt = Date.now();
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), args.timeoutMs);
+  try {
+    const response = await args.fetchImpl(args.target.endpoint, {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        authorization: `Bearer ${args.apiKey}`,
+      },
+      body: JSON.stringify({
+        model: args.target.model,
+        messages: [{ role: "user", content: "Reply with OK." }],
+        max_tokens: 8,
+        stream: false,
+      }),
+      signal: controller.signal,
+    });
+    const text = await response.text();
+    return {
+      ok: response.ok,
+      status: response.status,
+      latencyMs: Date.now() - startedAt,
+      message: extractMessage(text),
+      rateLimitHeaders: collectRateLimitHeaders(response.headers),
+    };
+  } catch (error) {
+    return {
+      ok: false,
+      latencyMs: Date.now() - startedAt,
+      message: error instanceof Error ? error.message : String(error),
+      rateLimitHeaders: {},
+    };
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+export async function runProviderHealthProbe({
+  attempts,
+  env = process.env,
+  fetchImpl = fetch,
+  targets = DEFAULT_PROVIDER_HEALTH_TARGETS,
+  timeoutMs = DEFAULT_TIMEOUT_MS,
+}: {
+  attempts?: number;
+  env?: Record<string, string | undefined>;
+  fetchImpl?: typeof fetch;
+  targets?: ProviderHealthProbeTarget[];
+  timeoutMs?: number;
+} = {}): Promise<ProviderHealthProbeResult[]> {
+  const attemptCount = clampAttempts(attempts);
+  const results: ProviderHealthProbeResult[] = [];
+
+  for (const target of targets) {
+    const apiKey = String(env[target.envKey] ?? "").trim();
+    const attemptResults: ProviderHealthProbeAttempt[] = [];
+    if (apiKey) {
+      for (let index = 0; index < attemptCount; index += 1) {
+        attemptResults.push(
+          await probeOnce({ target, apiKey, fetchImpl, timeoutMs })
+        );
+      }
+    }
+    results.push({
+      ...target,
+      keyConfigured: Boolean(apiKey),
+      attempts: attemptResults,
+      summary: summarizeAttempts(attemptResults),
+    });
+  }
+
+  return results;
+}

package/server/providerHealthRoutes.ts

@@ -0,0 +1,19 @@
+import { handleProviderHealth } from "./handlers/providerHealthHandler";
+
+const options = () =>
+  new Response(null, {
+    status: 204,
+    headers: {
+      "Access-Control-Allow-Origin": "*",
+      "Access-Control-Allow-Methods": "GET, OPTIONS",
+      "Access-Control-Allow-Headers": "Content-Type, Authorization",
+      "Access-Control-Max-Age": "86400",
+    },
+  });
+
+export const providerHealthRoutes: Record<string, any> = {
+  "/api/admin/provider-health": {
+    GET: handleProviderHealth,
+    OPTIONS: options,
+  },
+};

package/server/publicPaths.ts

@@ -0,0 +1,12 @@
+import { join } from "node:path";
+
+const resolvePublicDir = () => {
+  const configured = process.env.NOLO_PUBLIC_DIR?.trim();
+  if (configured) return configured;
+  return join(process.cwd(), "public");
+};
+
+export const getPublicDir = () => resolvePublicDir();
+
+export const resolvePublicPath = (...parts: string[]) =>
+  join(resolvePublicDir(), ...parts);

package/server/publicRequestHandler.ts

@@ -0,0 +1,15 @@
+import { resolvePublicPath } from "./publicPaths";
+
+export function handlePublicRequest(url: URL): Response {
+  const filePath = url.pathname.replace("/public", "");
+  // 检查是不是运行于Bun环境以使用Bun的文件API
+  if (typeof Bun !== "undefined" && Bun.file) {
+    const file = Bun.file(resolvePublicPath(filePath.replace(/^\/+/, "")));
+    const headers = new Headers({
+      "Cache-Control": "max-age=3600",
+      "Content-Type": file.type,
+    });
+    return new Response(file.stream(), { headers });
+  }
+  throw new Error("Bun.file is not available");
+}

package/server/reactAppBuilder.ts

@@ -0,0 +1,416 @@
+import { mkdir, unlink, writeFile } from "fs/promises";
+import { tmpdir } from "os";
+import { join } from "path";
+
+import type { BundleFile } from "./appBundler";
+import {
+  normalizeBundleRelativePath,
+  resolveSafeTempFile,
+} from "./safeTempFile";
+import { LU_ICON_NAMES, suggestLuIcon } from "./luIconNames";
+
+export interface ReactAppBuildResult {
+  workerCode: string;
+  html: string;
+  warnings: string[];
+  entryFile: string;
+  externalImports: string[];
+}
+
+export type ReactAppValidationIssueCode =
+  | "missing-files"
+  | "missing-entry-file"
+  | "invalid-file"
+  | "invalid-file-path"
+  | "css-import-disallowed"
+  | "unsupported-import"
+  | "invalid-icon-import";
+
+export interface ReactAppValidationIssue {
+  code: ReactAppValidationIssueCode;
+  message: string;
+  file?: string;
+  importSpecifier?: string;
+  symbol?: string;
+  suggestion?: string;
+}
+
+interface ReactAppValidationResult {
+  ok: boolean;
+  errors: string[];
+  warnings: string[];
+  entryFile?: string;
+  externalImports: string[];
+  issues: ReactAppValidationIssue[];
+}
+
+const REACT_ENTRY_NAMES = [
+  "main.tsx",
+  "main.jsx",
+  "main.ts",
+  "main.js",
+  "index.tsx",
+  "index.jsx",
+  "index.ts",
+  "index.js",
+];
+
+const BROWSER_IMPORT_MAP: Record<string, string> = {
+  react: "https://esm.sh/react@19.2.1",
+  "react/jsx-runtime": "https://esm.sh/react@19.2.1/jsx-runtime",
+  "react/jsx-dev-runtime": "https://esm.sh/react@19.2.1/jsx-dev-runtime",
+  "react-dom/client": "https://esm.sh/react-dom@19.2.1/client?deps=react@19.2.1",
+  "react-icons/lu": "https://esm.sh/react-icons@5.5.0/lu?deps=react@19.2.1",
+  echarts: "https://esm.sh/echarts@5.5.0",
+  "echarts-for-react":
+    "https://esm.sh/echarts-for-react@3.0.4?deps=react@19.2.1,react-dom@19.2.1,echarts@5.5.0",
+  docx: "https://esm.sh/docx@9.5.1",
+  "@xyflow/react":
+    "https://esm.sh/@xyflow/react@12.8.6?deps=react@19.2.1,react-dom@19.2.1",
+  three: "https://esm.sh/three@0.181.2",
+  "@react-three/fiber":
+    "https://esm.sh/@react-three/fiber@9.4.0?deps=react@19.2.1,react-dom@19.2.1,three@0.181.2",
+  "@react-three/drei":
+    "https://esm.sh/@react-three/drei@10.7.7?deps=react@19.2.1,react-dom@19.2.1,three@0.181.2,@react-three/fiber@9.4.0",
+  // Map & data packages
+  leaflet:
+    "https://esm.sh/leaflet@1.9.4",
+  "react-leaflet":
+    "https://esm.sh/react-leaflet@4.2.1?deps=react@19.2.1,react-dom@19.2.1,leaflet@1.9.4",
+  xlsx: "https://esm.sh/xlsx@0.18.5",
+  d3: "https://esm.sh/d3@7.9.0",
+  dayjs: "https://esm.sh/dayjs@1.11.13",
+  "recharts":
+    "https://esm.sh/recharts@2.15.0?deps=react@19.2.1,react-dom@19.2.1",
+};
+
+const STATIC_IMPORT_RE =
+  /\b(?:import|export)\s+(?:[\s\S]*?\s+from\s+)?['"]([^'"]+)['"]|\bimport\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
+
+const htmlEscape = (value: string): string =>
+  value
+    .replaceAll("&", "&amp;")
+    .replaceAll("<", "&lt;")
+    .replaceAll(">", "&gt;")
+    .replaceAll('"', "&quot;")
+    .replaceAll("'", "&#39;");
+
+function findEntryFile(files: BundleFile[]): string | undefined {
+  return files.find((file) => REACT_ENTRY_NAMES.includes(file.name.toLowerCase()))?.name;
+}
+
+function collectImportSpecifiers(code: string): string[] {
+  const imports: string[] = [];
+  for (const match of code.matchAll(STATIC_IMPORT_RE)) {
+    const specifier = match[1] || match[2];
+    if (specifier) imports.push(specifier);
+  }
+  return imports;
+}
+
+function isBareSpecifier(specifier: string): boolean {
+  return !specifier.startsWith(".") && !specifier.startsWith("/") && !specifier.startsWith("http://") && !specifier.startsWith("https://");
+}
+
+function collectExternalImports(files: BundleFile[]): string[] {
+  const imports = new Set<string>();
+  for (const file of files) {
+    for (const specifier of collectImportSpecifiers(file.code)) {
+      if (BROWSER_IMPORT_MAP[specifier]) imports.add(specifier);
+    }
+  }
+  imports.add("react/jsx-dev-runtime");
+  imports.add("react/jsx-runtime");
+  return [...imports].sort();
+}
+
+function findUnsupportedBareImports(files: BundleFile[]): string[] {
+  const unsupported = new Set<string>();
+  for (const file of files) {
+    for (const specifier of collectImportSpecifiers(file.code)) {
+      if (!isBareSpecifier(specifier)) continue;
+      if (!BROWSER_IMPORT_MAP[specifier]) unsupported.add(specifier);
+    }
+  }
+  return [...unsupported].sort();
+}
+
+export function validateReactAppFiles(files: BundleFile[]): ReactAppValidationResult {
+  const errors: string[] = [];
+  const warnings: string[] = [];
+  const issues: ReactAppValidationIssue[] = [];
+
+  if (!Array.isArray(files) || files.length === 0) {
+    const message = "React 应用必须提供 files 数组";
+    return {
+      ok: false,
+      errors: [message],
+      warnings,
+      externalImports: [],
+      issues: [{ code: "missing-files", message }],
+    };
+  }
+
+  const entryFile = findEntryFile(files);
+  if (!entryFile) {
+    const message = `未找到 React 入口文件。请提供 ${REACT_ENTRY_NAMES.join(" / ")} 之一`;
+    errors.push(message);
+    issues.push({ code: "missing-entry-file", message });
+  }
+
+  for (const file of files) {
+    if (!file.name || !file.code) {
+      const message = `文件 "${file.name || "(未命名)"}" 的 name 和 code 不能为空`;
+      errors.push(message);
+      issues.push({
+        code: "invalid-file",
+        message,
+        file: file.name || "(未命名)",
+      });
+      continue;
+    }
+    try {
+      normalizeBundleRelativePath(file.name);
+    } catch (error: any) {
+      const message = error?.message ?? `非法文件路径: ${file.name}`;
+      errors.push(message);
+      issues.push({
+        code: "invalid-file-path",
+        message,
+        file: file.name,
+      });
+      continue;
+    }
+    const cssImport = collectImportSpecifiers(file.code).find((specifier) => specifier.endsWith(".css"));
+    if (cssImport) {
+      const message = `暂不支持 CSS 文件导入（${file.name} -> ${cssImport}）。请先使用内联样式或 JS 内样式对象`;
+      errors.push(message);
+      issues.push({
+        code: "css-import-disallowed",
+        message,
+        file: file.name,
+        importSpecifier: cssImport,
+      });
+    }
+  }
+
+  const unsupportedBareImports = findUnsupportedBareImports(files);
+  if (unsupportedBareImports.length > 0) {
+    const message =
+      "当前 React SPA 模式仅支持内置白名单依赖。未支持的导入：" +
+      unsupportedBareImports.join(", ");
+    errors.push(message);
+    for (const importSpecifier of unsupportedBareImports) {
+      issues.push({
+        code: "unsupported-import",
+        message: `未支持的导入：${importSpecifier}`,
+        importSpecifier,
+      });
+    }
+  }
+
+  // ── Icon name validation: catch LuXxx typos before deploy ─────────────────
+  for (const file of files) {
+    const luImportRegex = /import\s*\{([^}]+)\}\s*from\s*['"]react-icons\/lu['"]/g;
+    let m: RegExpExecArray | null;
+    while ((m = luImportRegex.exec(file.code)) !== null) {
+      const names = m[1]
+        .split(",")
+        .map((s) => {
+          // "type LuCode as Foo" → strip leading "type " first, then strip "as alias"
+          const stripped = s.trim().replace(/^type\s+/, "");
+          return stripped.split(/\s+as\s+/)[0].trim();
+        })
+        .filter(Boolean);
+      for (const name of names) {
+        if (name && !LU_ICON_NAMES.has(name)) {
+          const suggestion = suggestLuIcon(name);
+          const message =
+            `react-icons/lu 中不存在图标 "${name}"（${file.name}）` +
+            (suggestion ? `，是否是 "${suggestion}"？` : "。请查阅 https://lucide.dev/icons/");
+          errors.push(message);
+          issues.push({
+            code: "invalid-icon-import",
+            message,
+            file: file.name,
+            symbol: name,
+            suggestion: suggestion ?? undefined,
+          });
+        }
+      }
+    }
+  }
+  // ──────────────────────────────────────────────────────────────────────────
+
+  const externalImports = collectExternalImports(files);
+  if (!externalImports.includes("react") || !externalImports.includes("react-dom/client")) {
+    warnings.push("推荐在入口文件中显式导入 react 与 react-dom/client");
+  }
+
+  return {
+    ok: errors.length === 0,
+    errors,
+    warnings,
+    entryFile,
+    externalImports,
+    issues,
+  };
+}
+
+function escapeInlineScript(code: string): string {
+  return code.replaceAll("</script", "<\\/script").replaceAll("<!--", "<\\!--");
+}
+
+function createImportMap(externalImports: string[]): string {
+  const imports = Object.fromEntries(
+    externalImports.map((specifier) => [specifier, BROWSER_IMPORT_MAP[specifier]])
+  );
+  return JSON.stringify({ imports });
+}
+
+function createReactHtml(appName: string, bundleCode: string, externalImports: string[]): string {
+  const importMap = createImportMap(externalImports);
+  const safeTitle = htmlEscape(appName);
+  const safeBundle = escapeInlineScript(bundleCode);
+
+  // Auto-inject CSS for packages that ship required stylesheets
+  const cssLinks: string[] = [];
+  if (externalImports.includes("leaflet") || externalImports.includes("react-leaflet")) {
+    cssLinks.push(
+      '<link rel="stylesheet" href="https://unpkg.com/leaflet@1.9.4/dist/leaflet.css" />'
+    );
+  }
+
+  return `<!DOCTYPE html>
+<html lang="zh-CN">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>${safeTitle}</title>
+    ${cssLinks.join("\n    ")}
+    <style>
+      html, body, #root {
+        width: 100%;
+        min-height: 100%;
+        margin: 0;
+      }
+      body {
+        font-family: Inter, system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif;
+        background: #ffffff;
+        color: #111827;
+      }
+      * {
+        box-sizing: border-box;
+      }
+    </style>
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="importmap">${importMap}</script>
+    <script type="module">${safeBundle}</script>
+  </body>
+</html>`;
+}
+
+function createWorkerCode(html: string): string {
+  return `const APP_HTML = ${JSON.stringify(html)};
+
+export default {
+  async fetch(request) {
+    if (request.method !== "GET" && request.method !== "HEAD") {
+      return new Response("Method Not Allowed", {
+        status: 405,
+        headers: { Allow: "GET, HEAD" },
+      });
+    }
+
+    return new Response(request.method === "HEAD" ? null : APP_HTML, {
+      headers: {
+        "Content-Type": "text/html; charset=utf-8",
+        "Cache-Control": "no-store",
+      },
+    });
+  },
+};`;
+}
+
+export async function buildReactSpaApp(
+  files: BundleFile[],
+  options: { appName: string }
+): Promise<ReactAppBuildResult> {
+  const normalizedFiles = files.map((file) => ({
+    ...file,
+    name: normalizeBundleRelativePath(file.name),
+  }));
+  const validation = validateReactAppFiles(normalizedFiles);
+  if (!validation.ok || !validation.entryFile) {
+    throw new Error(validation.errors.join("\n"));
+  }
+
+  const tmpDir = join(tmpdir(), `nolo-react-spa-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`);
+  const writtenFiles: string[] = [];
+
+  try {
+    await mkdir(tmpDir, { recursive: true });
+
+    for (const file of normalizedFiles) {
+      const { absolutePath, dir } = resolveSafeTempFile(tmpDir, file.name);
+      if (dir && dir !== tmpDir) await mkdir(dir, { recursive: true });
+      await writeFile(absolutePath, file.code, "utf-8");
+      writtenFiles.push(absolutePath);
+    }
+
+    const totalInputSize = files.reduce((sum, f) => sum + Buffer.byteLength(f.code, "utf-8"), 0);
+    const largeInputHint =
+      totalInputSize > 200 * 1024
+        ? `输入总大小 ${Math.round(totalInputSize / 1024)}KB，建议将大型常量数据改成运行时按需加载（例如 fetch 独立 JSON）或精简内容。`
+        : "";
+
+    let result: Awaited<ReturnType<typeof Bun.build>>;
+    try {
+      result = await Bun.build({
+        entrypoints: [join(tmpDir, validation.entryFile)],
+        target: "browser",
+        format: "esm",
+        minify: true,
+        sourcemap: "none",
+        external: validation.externalImports,
+      });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      throw new Error([message || "Bundle failed", largeInputHint].filter(Boolean).join("\n"));
+    }
+
+    if (!result.success) {
+      const errorLogs = result.logs
+        .filter((log) => log.level === "error")
+        .map((log) => log.message)
+        .join("\n");
+      throw new Error([errorLogs || "构建器未返回详细错误。", largeInputHint].filter(Boolean).join("\n"));
+    }
+
+    const jsOutput = result.outputs.find((output) => output.path.endsWith(".js")) ?? result.outputs[0];
+    const bundleCode = await jsOutput.text();
+    const html = createReactHtml(options.appName, bundleCode, validation.externalImports);
+
+    return {
+      workerCode: createWorkerCode(html),
+      html,
+      warnings: [
+        ...validation.warnings,
+        ...result.logs.filter((log) => log.level === "warning").map((log) => log.message),
+      ],
+      entryFile: validation.entryFile,
+      externalImports: validation.externalImports,
+    };
+  } finally {
+    await Promise.all(writtenFiles.map((file) => unlink(file).catch(() => {})));
+    import("fs")
+      .then(({ rmSync }) => {
+        try {
+          rmSync(tmpDir, { recursive: true, force: true });
+        } catch {}
+      })
+      .catch(() => {});
+  }
+}