nolo-cli 0.1.23 → 0.1.29

package/server/handlers/checkEnvHandler.ts

@@ -0,0 +1,250 @@
+// 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,
+            }
+        );
+    }
+}

package/server/handlers/cliChatHandler.ts

@@ -0,0 +1,266 @@
+// 文件路径: server/handlers/cliChatHandler.ts
+import { authenticateRequest } from "../../auth/utils";
+import {
+  closeCliSession,
+  executeCliSessionTurn,
+  executeCliSessionTurnStreaming,
+  executeCliStreaming,
+  getCliSession,
+  startCliSession,
+  type CliProvider,
+} from "../../ai/agent/cliExecutor";
+
+const CORS_HEADERS = {
+  "Access-Control-Allow-Origin": "*",
+  "Access-Control-Allow-Methods": "POST, OPTIONS",
+  "Access-Control-Allow-Headers": "Content-Type, Authorization",
+};
+
+export const handleCliChat = async (req: Request): Promise<Response> => {
+  if (req.method === "OPTIONS") {
+    return new Response(null, { status: 204, headers: CORS_HEADERS });
+  }
+
+  const auth = await authenticateRequest(req);
+  if (auth instanceof Response) return auth;
+
+  try {
+    const body = await req.json();
+    const {
+      action,
+      prompt,
+      model,
+      cliProvider = "copilot",
+      systemPrompt,
+      reasoningEffort,
+      temperature,
+      topP,
+      frequencyPenalty,
+      presencePenalty,
+      maxTokens,
+      enableThinking,
+      thinkingBudget,
+      sessionId,
+      stream: streamMode,
+    } = body as {
+      action?: "start" | "turn" | "get" | "close";
+      prompt: string;
+      model?: string;
+      cliProvider?: CliProvider;
+      systemPrompt?: string;
+      reasoningEffort?: "low" | "medium" | "high" | "xhigh" | "max";
+      temperature?: number;
+      topP?: number;
+      frequencyPenalty?: number;
+      presencePenalty?: number;
+      maxTokens?: number;
+      enableThinking?: boolean;
+      thinkingBudget?: number;
+      sessionId?: string;
+      stream?: boolean;
+    };
+
+    if (action === "start") {
+      const session = startCliSession(cliProvider, {
+        model,
+        systemPrompt,
+        reasoningEffort,
+        temperature,
+        topP,
+        frequencyPenalty,
+        presencePenalty,
+        maxTokens,
+        enableThinking,
+        thinkingBudget,
+      });
+      return new Response(
+        JSON.stringify({
+          ok: true,
+          ...session,
+        }),
+        { status: 200, headers: { ...CORS_HEADERS, "Content-Type": "application/json" } }
+      );
+    }
+
+    if (action === "get") {
+      if (!sessionId || typeof sessionId !== "string") {
+        return new Response(
+          JSON.stringify({ error: "sessionId 参数是必需的" }),
+          { status: 400, headers: { ...CORS_HEADERS, "Content-Type": "application/json" } }
+        );
+      }
+
+      const session = getCliSession(sessionId);
+      return new Response(
+        JSON.stringify({
+          ok: !!session,
+          session: session ?? null,
+        }),
+        { status: session ? 200 : 404, headers: { ...CORS_HEADERS, "Content-Type": "application/json" } }
+      );
+    }
+
+    if (action === "close") {
+      if (!sessionId || typeof sessionId !== "string") {
+        return new Response(
+          JSON.stringify({ error: "sessionId 参数是必需的" }),
+          { status: 400, headers: { ...CORS_HEADERS, "Content-Type": "application/json" } }
+        );
+      }
+
+      const closed = closeCliSession(sessionId);
+      return new Response(
+        JSON.stringify({
+          ok: closed,
+          sessionId,
+        }),
+        {
+          status: closed ? 200 : 404,
+          headers: { ...CORS_HEADERS, "Content-Type": "application/json" },
+        }
+      );
+    }
+
+    if (!prompt || typeof prompt !== "string") {
+      return new Response(
+        JSON.stringify({ error: "prompt 参数是必需的" }),
+        { status: 400, headers: { ...CORS_HEADERS, "Content-Type": "application/json" } }
+      );
+    }
+
+    if (action === "turn") {
+      if (!sessionId || typeof sessionId !== "string") {
+        return new Response(
+          JSON.stringify({ error: "sessionId 参数是必需的" }),
+          { status: 400, headers: { ...CORS_HEADERS, "Content-Type": "application/json" } }
+        );
+      }
+
+      const existingSession = getCliSession(sessionId);
+      if (!existingSession) {
+        return new Response(
+          JSON.stringify({ error: `CLI session not found: ${sessionId}` }),
+          { status: 404, headers: { ...CORS_HEADERS, "Content-Type": "application/json" } }
+        );
+      }
+
+      if (streamMode === false) {
+        const result = await executeCliSessionTurn(sessionId, prompt, {
+          model,
+          reasoningEffort,
+          temperature,
+          topP,
+          frequencyPenalty,
+          presencePenalty,
+          maxTokens,
+          enableThinking,
+          thinkingBudget,
+        });
+        return new Response(
+          JSON.stringify({
+            ok: true,
+            sessionId: result.sessionId,
+            text: result.text,
+            elapsed: result.elapsed,
+            warnings: result.warnings ?? [],
+          }),
+          { status: 200, headers: { ...CORS_HEADERS, "Content-Type": "application/json" } }
+        );
+      }
+
+      const streamResponse = new ReadableStream({
+        start(controller) {
+          const encode = (s: string) => new TextEncoder().encode(s);
+
+          executeCliSessionTurnStreaming(sessionId, prompt, {
+            model,
+            reasoningEffort,
+            temperature,
+            topP,
+            frequencyPenalty,
+            presencePenalty,
+            maxTokens,
+            enableThinking,
+            thinkingBudget,
+            onChunk: (chunk: string) => {
+              controller.enqueue(encode(`data: ${JSON.stringify({ chunk })}\n\n`));
+            },
+          })
+            .then((result) => {
+              controller.enqueue(
+                encode(`data: ${JSON.stringify({ done: true, elapsed: result.elapsed, sessionId: result.sessionId, warnings: result.warnings ?? [] })}\n\n`)
+              );
+              controller.close();
+            })
+            .catch((err: Error) => {
+              controller.enqueue(
+                encode(`data: ${JSON.stringify({ error: err.message })}\n\n`)
+              );
+              controller.close();
+            });
+        },
+      });
+
+      return new Response(streamResponse, {
+        status: 200,
+        headers: {
+          ...CORS_HEADERS,
+          "Content-Type": "text/event-stream",
+          "Cache-Control": "no-cache",
+          Connection: "keep-alive",
+        },
+      });
+    }
+
+    // SSE 流式响应
+    const sseStream = new ReadableStream({
+      start(controller) {
+        const encode = (s: string) => new TextEncoder().encode(s);
+
+        executeCliStreaming(cliProvider, prompt, {
+          model,
+          systemPrompt,
+          reasoningEffort,
+          temperature,
+          topP,
+          frequencyPenalty,
+          presencePenalty,
+          maxTokens,
+          enableThinking,
+          thinkingBudget,
+          onChunk: (chunk: string) => {
+            controller.enqueue(encode(`data: ${JSON.stringify({ chunk })}\n\n`));
+          },
+        })
+          .then((result) => {
+            controller.enqueue(
+              encode(`data: ${JSON.stringify({ done: true, elapsed: result.elapsed, warnings: result.warnings ?? [] })}\n\n`)
+            );
+            controller.close();
+          })
+          .catch((err: Error) => {
+            controller.enqueue(
+              encode(`data: ${JSON.stringify({ error: err.message })}\n\n`)
+            );
+            controller.close();
+          });
+      },
+    });
+
+    return new Response(sseStream, {
+      status: 200,
+      headers: {
+        ...CORS_HEADERS,
+        "Content-Type": "text/event-stream",
+        "Cache-Control": "no-cache",
+        Connection: "keep-alive",
+      },
+    });
+  } catch (error: any) {
+    console.error("[cliChatHandler] error:", error);
+    return new Response(
+      JSON.stringify({ error: error?.message || "CLI 执行失败" }),
+      { status: 500, headers: { ...CORS_HEADERS, "Content-Type": "application/json" } }
+    );
+  }
+};