nolo-cli 0.1.31 → 0.1.32

package/server/handlers/chatUpstreamRetry.ts

@@ -1,385 +0,0 @@
-type RetryLogger = {
-  warn?: (...args: any[]) => void;
-  error?: (...args: any[]) => void;
-};
-
-import type { OpenAIServiceTier } from "../../integrations/openai/flexTier";
-import { isFireworksKimiModel } from "../../ai/llm/kimi";
-import {
-  createProviderCallCompletedEvent,
-} from "../../ai/token/providerCall";
-import {
-  writeProviderCallEvent,
-  type ProviderCallStore,
-} from "../../ai/token/providerCallWriter";
-import { dispatchProviderRequest } from "../../ai/token/providerGateway";
-import type { ProviderCredentialIdentity } from "../../ai/token/providerCredential";
-import { writeBillingAnomaly } from "../../ai/token/billingAnomalyWriter";
-import {
-  writeRevokedProviderCredentialUsedAnomalyIfNeeded,
-} from "../../ai/token/providerCredentialAnomaly";
-import { ulid } from "ulid";
-
-const FIREWORKS_GENTLE_RETRY_DELAY_MS = 1200;
-const FIREWORKS_GENTLE_RETRY_STATUSES = new Set([429, 503]);
-
-type UpstreamRequest = {
-  url: string;
-  init: RequestInit;
-  provider?: string;
-  model?: string;
-  serviceTier?: OpenAIServiceTier;
-  credential?: ProviderCredentialIdentity;
-};
-
-type ProviderCallContext = {
-  userId: string;
-  dialogId?: string;
-  agentId?: string;
-  endpoint?: string;
-  credential?: ProviderCredentialIdentity;
-};
-
-const isoNow = () => new Date().toISOString();
-type ProviderCallWriter = typeof writeProviderCallEvent;
-type BillingAnomalyWriter = typeof writeBillingAnomaly;
-type ProviderDispatchIntentWriter =
-  NonNullable<Parameters<typeof dispatchProviderRequest>[0]["writers"]>["providerDispatchIntentWriter"];
-
-async function writeProviderCallEvidence({
-  store,
-  event,
-  providerCallWriter,
-}: {
-  store: ProviderCallStore;
-  event: Parameters<typeof writeProviderCallEvent>[0]["event"];
-  providerCallWriter?: ProviderCallWriter;
-}) {
-  const writer = providerCallWriter ?? writeProviderCallEvent;
-  if (typeof writer === "function") {
-    return writer({ store, event });
-  }
-  const key = `provider-call-${event.providerCallId}-event-${event.eventId}`;
-  await store.put(key, event);
-  return { key };
-}
-
-async function writeTerminalProviderCallEventSafely({
-  store,
-  event,
-  log,
-  providerCallWriter = writeProviderCallEvent,
-  billingAnomalyWriter = writeBillingAnomaly,
-}: {
-  store: ProviderCallStore;
-  event: Parameters<typeof writeProviderCallEvent>[0]["event"];
-  log?: RetryLogger;
-  providerCallWriter?: ProviderCallWriter;
-  billingAnomalyWriter?: BillingAnomalyWriter;
-}) {
-  try {
-    await writeProviderCallEvidence({ store, event, providerCallWriter });
-  } catch (error) {
-    log?.error?.("provider-call terminal event write failed", {
-      err: error,
-      providerCallId: event.providerCallId,
-      status: event.status,
-    });
-    return;
-  }
-  await writeRevokedProviderCredentialUsedAnomalyIfNeeded({
-    store,
-    event,
-    onError: (error) =>
-      log?.error?.("provider-call revoked credential anomaly write failed", {
-        err: error,
-        providerCallId: event.providerCallId,
-      }),
-    billingAnomalyWriter,
-  });
-}
-
-async function fetchWithProviderCallEvidence({
-  url,
-  init,
-  provider,
-  model,
-  serviceTier,
-  fetchImpl,
-  providerCallStore,
-  providerCallContext,
-  log,
-  providerCallWriter,
-  providerDispatchIntentWriter,
-  billingAnomalyWriter,
-  credential,
-}: {
-  url: string;
-  init: RequestInit;
-  provider?: string;
-  model?: string;
-  serviceTier?: OpenAIServiceTier;
-  fetchImpl: typeof fetch;
-  providerCallStore?: ProviderCallStore;
-  providerCallContext?: ProviderCallContext;
-  log?: RetryLogger;
-  providerCallWriter?: ProviderCallWriter;
-  providerDispatchIntentWriter?: ProviderDispatchIntentWriter;
-  billingAnomalyWriter?: BillingAnomalyWriter;
-  credential?: ProviderCredentialIdentity;
-}): Promise<{ response: Response; providerCallId?: string }> {
-  if (!providerCallStore || !providerCallContext) {
-    return { response: await fetchImpl(url, init) };
-  }
-
-  const providerCallId = `call_${ulid()}`;
-  const startedAt = isoNow();
-
-  const { response } = await dispatchProviderRequest({
-    store: providerCallStore,
-    fetchImpl,
-    now: () => new Date(startedAt),
-    ids: {
-      providerCallId: () => providerCallId,
-      pendingEventId: () => `evt_${ulid()}`,
-      dispatchIntentId: () => `intent_${ulid()}`,
-      failedEventId: () => `evt_${ulid()}`,
-    },
-    writers: {
-      providerCallWriter,
-      providerDispatchIntentWriter,
-      billingAnomalyWriter,
-    },
-    call: {
-      userId: providerCallContext.userId,
-      dialogId: providerCallContext.dialogId,
-      agentId: providerCallContext.agentId,
-      provider: provider || "unknown",
-      model: model || "unknown",
-      endpoint: providerCallContext.endpoint,
-      serviceTier,
-      credential: credential ?? providerCallContext.credential,
-      url,
-      init,
-    },
-  });
-  await writeTerminalProviderCallEventSafely({
-    store: providerCallStore,
-    log,
-    providerCallWriter,
-    billingAnomalyWriter,
-    event: createProviderCallCompletedEvent({
-      providerCallId,
-      eventId: `evt_${ulid()}`,
-      userId: providerCallContext.userId,
-      dialogId: providerCallContext.dialogId,
-      agentId: providerCallContext.agentId,
-      provider: provider || "unknown",
-      model: model || "unknown",
-      endpoint: providerCallContext.endpoint,
-      serviceTier,
-      credential: credential ?? providerCallContext.credential,
-      startedAt,
-      completedAt: isoNow(),
-      inputTokens: 0,
-      outputTokens: 0,
-      cacheCreationInputTokens: 0,
-      cacheReadInputTokens: 0,
-      billingStatus: "unpriced",
-    }),
-  });
-  return { response, providerCallId };
-}
-
-function createAbortError(reason?: unknown): Error {
-  const error = new Error(typeof reason === "string" ? reason : "Aborted");
-  error.name = "AbortError";
-  return error;
-}
-
-async function sleepWithAbort(ms: number, signal?: AbortSignal): Promise<void> {
-  if (!signal) {
-    await new Promise((resolve) => setTimeout(resolve, ms));
-    return;
-  }
-
-  if (signal.aborted) throw createAbortError(signal.reason);
-
-  await new Promise<void>((resolve, reject) => {
-    const timer = setTimeout(() => {
-      signal.removeEventListener("abort", onAbort);
-      resolve();
-    }, ms);
-
-    const onAbort = () => {
-      clearTimeout(timer);
-      signal.removeEventListener("abort", onAbort);
-      reject(createAbortError(signal.reason));
-    };
-
-    signal.addEventListener("abort", onAbort, { once: true });
-  });
-}
-
-export async function fetchUpstreamWithGentleRetry({
-  url,
-  init,
-  provider,
-  model,
-  log,
-  fallbackRequest,
-  fallbackRequests,
-  fallbackOnStatuses,
-  retryDelayMs = FIREWORKS_GENTLE_RETRY_DELAY_MS,
-  fetchImpl = fetch,
-  providerCallStore,
-  providerCallContext,
-  providerCallWriter,
-  providerDispatchIntentWriter,
-  billingAnomalyWriter,
-  credential,
-}: {
-  url: string;
-  init: RequestInit;
-  provider?: string;
-  model?: string;
-  log?: RetryLogger;
-  fallbackRequest?: UpstreamRequest;
-  fallbackRequests?: UpstreamRequest[];
-  fallbackOnStatuses?: Iterable<number>;
-  retryDelayMs?: number;
-  fetchImpl?: typeof fetch;
-  providerCallStore?: ProviderCallStore;
-  providerCallContext?: ProviderCallContext;
-  providerCallWriter?: ProviderCallWriter;
-  providerDispatchIntentWriter?: ProviderDispatchIntentWriter;
-  billingAnomalyWriter?: BillingAnomalyWriter;
-  credential?: ProviderCredentialIdentity;
-}): Promise<{
-  response: Response;
-  provider?: string;
-  model?: string;
-  serviceTier?: OpenAIServiceTier;
-  providerCallIds?: string[];
-}> {
-  const maxAttempts = provider === "fireworks" ? 2 : 1;
-  let response: Response | undefined;
-  const providerCallIds: string[] = [];
-
-  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
-    const evidence = await fetchWithProviderCallEvidence({
-      url,
-      init,
-      provider,
-      model,
-      fetchImpl,
-      providerCallStore,
-      providerCallContext,
-      log,
-      providerCallWriter,
-      providerDispatchIntentWriter,
-      billingAnomalyWriter,
-      credential,
-    });
-    response = evidence.response;
-    if (evidence.providerCallId) providerCallIds.push(evidence.providerCallId);
-    const shouldRetry =
-      provider === "fireworks" &&
-      attempt < maxAttempts &&
-      FIREWORKS_GENTLE_RETRY_STATUSES.has(response.status);
-
-    if (!shouldRetry) break;
-
-    log?.warn?.("Fireworks 上游繁忙，准备温和重试一次", {
-      provider,
-      model,
-      status: response.status,
-      retryDelayMs,
-      attempt,
-    });
-
-    await sleepWithAbort(retryDelayMs, init.signal as AbortSignal | undefined);
-  }
-
-  if (!response) {
-    throw new Error("Unexpected retry state");
-  }
-
-  const fallbackStatuses = fallbackOnStatuses
-    ? new Set(Array.from(fallbackOnStatuses))
-      : provider === "fireworks" && isFireworksKimiModel(model)
-      ? FIREWORKS_GENTLE_RETRY_STATUSES
-      : null;
-  const fallbackQueue =
-    fallbackRequests && fallbackRequests.length > 0
-      ? fallbackRequests
-      : fallbackRequest
-        ? [fallbackRequest]
-        : [];
-  const shouldFallback =
-    fallbackQueue.length > 0 &&
-    !!fallbackStatuses &&
-    fallbackStatuses.has(response.status);
-
-  if (!shouldFallback) {
-    return {
-      response,
-      provider,
-      model,
-      ...(providerCallIds.length > 0 ? { providerCallIds: [...providerCallIds] } : {}),
-    };
-  }
-
-  let currentProvider = provider;
-  let currentModel = model;
-  let currentStatus = response.status;
-
-  for (const nextFallback of fallbackQueue) {
-    log?.warn?.("上游请求失败，切换到 fallback provider", {
-      provider: currentProvider,
-      model: currentModel,
-      status: currentStatus,
-      fallbackProvider: nextFallback.provider,
-      fallbackModel: nextFallback.model,
-    });
-
-    const fallbackEvidence = await fetchWithProviderCallEvidence({
-      url: nextFallback.url,
-      init: nextFallback.init,
-      provider: nextFallback.provider,
-      model: nextFallback.model,
-      serviceTier: nextFallback.serviceTier,
-      fetchImpl,
-      providerCallStore,
-      providerCallContext,
-      log,
-      providerCallWriter,
-      providerDispatchIntentWriter,
-      billingAnomalyWriter,
-      credential: nextFallback.credential,
-    });
-    const fallbackResponse = fallbackEvidence.response;
-    if (fallbackEvidence.providerCallId) providerCallIds.push(fallbackEvidence.providerCallId);
-    if (!fallbackStatuses.has(fallbackResponse.status)) {
-      return {
-        response: fallbackResponse,
-        provider: nextFallback.provider,
-        model: nextFallback.model,
-        serviceTier: nextFallback.serviceTier,
-        ...(providerCallIds.length > 0 ? { providerCallIds: [...providerCallIds] } : {}),
-      };
-    }
-
-    response = fallbackResponse;
-    currentProvider = nextFallback.provider;
-    currentModel = nextFallback.model;
-    currentStatus = fallbackResponse.status;
-  }
-
-  return {
-    response,
-    provider: currentProvider,
-    model: currentModel,
-    ...(providerCallIds.length > 0 ? { providerCallIds: [...providerCallIds] } : {}),
-  };
-}

package/server/handlers/checkEnvHandler.ts

@@ -1,250 +0,0 @@
-// packages/server/handlers/checkEnvHandler.ts
-// 环境检查接口：默认执行 bun run build，返回结构化结果
-
-type CheckEnvRequestBody = {
-    check?: "build" | "context";
-    key?: string;
-};
-
-const JSON_HEADERS = {
-    "Content-Type": "application/json; charset=utf-8",
-};
-
-type ProbeResult = {
-    label: string;
-    ok: boolean;
-    command?: string[];
-    exitCode?: number;
-    stdout?: string;
-    stderr?: string;
-    error?: string;
-};
-
-const SUPPORTED_TOOL_KEYS = new Set(["gemini", "node", "npm", "bun", "python", "git", "shell"]);
-
-const runProbe = async (
-    label: string,
-    command: string[],
-    options: { timeoutMs?: number } = {}
-): Promise<ProbeResult> => {
-    const timeoutMs = options.timeoutMs ?? 12000;
-    let timedOut = false;
-    const proc = Bun.spawn(command, {
-        cwd: process.cwd(),
-        stdin: "ignore",
-        stdout: "pipe",
-        stderr: "pipe",
-    });
-
-    const timeout = setTimeout(() => {
-        timedOut = true;
-        proc.kill();
-    }, timeoutMs);
-
-    try {
-        const [stdout, stderr, exitCode] = await Promise.all([
-            new Response(proc.stdout).text(),
-            new Response(proc.stderr).text(),
-            proc.exited,
-        ]);
-        return {
-            label,
-            ok: !timedOut && exitCode === 0,
-            command,
-            exitCode,
-            stdout,
-            stderr,
-            ...(timedOut ? { error: `Timed out after ${timeoutMs}ms` } : {}),
-        };
-    } catch (error: any) {
-        return {
-            label,
-            ok: false,
-            command,
-            error: error?.message || String(error),
-        };
-    } finally {
-        clearTimeout(timeout);
-    }
-};
-
-const buildToolProbes = async (key: string): Promise<ProbeResult[]> => {
-    if (key === "bun") {
-        return [
-            {
-                label: "bun version",
-                ok: true,
-                stdout: Bun.version,
-            },
-            await runProbe("bun --version", ["bun", "--version"]),
-        ];
-    }
-    if (key === "node") {
-        return [
-            await runProbe("node --version", ["node", "--version"]),
-            await runProbe("npm --version", ["npm", "--version"]),
-        ];
-    }
-    if (key === "npm") {
-        return [await runProbe("npm --version", ["npm", "--version"])];
-    }
-    if (key === "gemini") {
-        return [
-            await runProbe("gemini --version", ["gemini", "--version"]),
-            await runProbe("npm latest @google/gemini-cli", ["npm", "view", "@google/gemini-cli", "version"], {
-                timeoutMs: 15000,
-            }),
-        ];
-    }
-    if (key === "python") {
-        return [
-            await runProbe("python3 --version", ["python3", "--version"]),
-            await runProbe("python --version", ["python", "--version"]),
-        ];
-    }
-    if (key === "git") {
-        return [await runProbe("git --version", ["git", "--version"])];
-    }
-
-    const hasPwsh = !!Bun.which("pwsh");
-    const hasPowerShell = !!Bun.which("powershell.exe") || !!Bun.which("powershell");
-    const hasBash = !!Bun.which("bash");
-    return [
-        {
-            label: "shell availability",
-            ok: hasBash || hasPwsh || hasPowerShell,
-            stdout: JSON.stringify({ bash: hasBash, powershell: hasPowerShell, pwsh: hasPwsh }),
-        },
-    ];
-};
-
-export async function handleCheckEnv(req: Request): Promise<Response> {
-    try {
-        let body: unknown;
-        try {
-            body = await req.json();
-        } catch {
-            body = {}; // 允许空 body，使用默认值
-        }
-
-        const { check, key }: Partial<CheckEnvRequestBody> =
-            typeof body === "object" && body !== null ? (body as any) : {};
-
-        const toolKey = typeof key === "string" ? key.trim().toLowerCase() : "";
-        if (toolKey) {
-            if (!SUPPORTED_TOOL_KEYS.has(toolKey)) {
-                return new Response(
-                    JSON.stringify({
-                        error: `Unsupported tool key: ${toolKey}. Supported keys: ${Array.from(SUPPORTED_TOOL_KEYS).join(", ")}.`,
-                    }),
-                    { status: 400, headers: JSON_HEADERS }
-                );
-            }
-
-            const probes = await buildToolProbes(toolKey);
-            return new Response(
-                JSON.stringify({
-                    ok: probes.some((probe) => probe.ok),
-                    check: "tool",
-                    key: toolKey,
-                    cwd: process.cwd(),
-                    platform: process.platform,
-                    probes,
-                }),
-                {
-                    status: 200,
-                    headers: JSON_HEADERS,
-                }
-            );
-        }
-
-        const checkType = check ?? "build";
-
-        if (checkType !== "build" && checkType !== "context") {
-            return new Response(
-                JSON.stringify({
-                    error: `Unsupported check type: ${checkType}. Currently only "build" and "context" are supported.`,
-                }),
-                { status: 400, headers: JSON_HEADERS }
-            );
-        }
-
-        if (checkType === "context") {
-            const hasPwsh = !!Bun.which("pwsh");
-            const hasPowerShell = !!Bun.which("powershell.exe") || !!Bun.which("powershell");
-            const hasBash = !!Bun.which("bash");
-            const defaultShell =
-                process.platform === "win32"
-                    ? (hasPwsh || hasPowerShell ? "powershell" : hasBash ? "bash" : null)
-                    : (hasBash ? "bash" : hasPwsh || hasPowerShell ? "powershell" : null);
-
-            return new Response(
-                JSON.stringify({
-                    ok: true,
-                    check: "context",
-                    platform: process.platform,
-                    cwd: process.cwd(),
-                    bunVersion: Bun.version,
-                    defaultShell,
-                    shells: {
-                        bash: hasBash,
-                        powershell: hasPowerShell,
-                        pwsh: hasPwsh,
-                    },
-                }),
-                {
-                    status: 200,
-                    headers: JSON_HEADERS,
-                }
-            );
-        }
-
-        // 执行 production build，避免 dev-style 资源路径掩盖真实部署问题
-        const proc = Bun.spawn(["bun", "run", "build"], {
-            cwd: process.cwd(),
-            stdin: "ignore",
-            stdout: "pipe",
-            stderr: "pipe",
-            env: {
-                ...process.env,
-                NODE_ENV: "production",
-                NOLO_FORCE_PRODUCTION: "1",
-            },
-        });
-
-        const [stdout, stderr] = await Promise.all([
-            new Response(proc.stdout).text(),
-            new Response(proc.stderr).text(),
-        ]);
-
-        const exitCode = await proc.exited;
-        const ok = exitCode === 0;
-
-        return new Response(
-            JSON.stringify({
-                ok,
-                check: checkType,
-                exitCode,
-                stdout,
-                stderr,
-            }),
-            {
-                status: 200,
-                headers: JSON_HEADERS,
-            }
-        );
-    } catch (error: any) {
-        console.error("[check-env] Error:", error);
-        return new Response(
-            JSON.stringify({
-                ok: false,
-                check: "build",
-                error: `Check failed: ${error?.message || String(error)}`,
-            }),
-            {
-                status: 500,
-                headers: JSON_HEADERS,
-            }
-        );
-    }
-}