nolo-cli 0.1.23 → 0.1.29

package/server/handlers/codeSearchHandler.ts

@@ -0,0 +1,484 @@
+import { readdirSync, readFileSync, statSync } from "node:fs";
+import { join, relative, resolve, sep } from "node:path";
+
+type CodeSearchRequestBody = {
+    query?: string;
+    path?: string;
+    glob?: string;
+    mode?: "content" | "files";
+    maxResults?: number;
+    caseSensitive?: boolean;
+};
+
+const JSON_HEADERS = { "Content-Type": "application/json; charset=utf-8" };
+const ROOT = process.cwd();
+const MAX_FALLBACK_FILE_BYTES = 512 * 1024;
+const EXCLUDE_GLOBS = [
+    "!**/node_modules/**",
+    "!**/.git/**",
+    "!**/dist/**",
+    "!**/build/**",
+    "!**/.next/**",
+    "!**/.gemini/**",
+];
+
+function resolvePathUnderRoot(pathScope: string): string {
+    const absRoot = ROOT.endsWith(sep) ? ROOT : `${ROOT}${sep}`;
+    const absPath = resolve(ROOT, pathScope || ".");
+    if (!absPath.startsWith(absRoot) && absPath !== ROOT) {
+        throw new Error("path 必须位于项目根目录内");
+    }
+    return absPath;
+}
+
+function parsePositiveInt(value: unknown, fallback: number, max: number): number {
+    if (value === undefined || value === null) return fallback;
+    if (typeof value !== "number" || !Number.isInteger(value) || value <= 0) {
+        throw new Error("maxResults 必须是正整数");
+    }
+    return Math.min(value, max);
+}
+
+function toProjectRelativePath(searchRoot: string, outputPath: string): string {
+    return relative(ROOT, resolve(searchRoot, outputPath));
+}
+
+function toPosixPath(value: string): string {
+    return value.replaceAll("\\", "/");
+}
+
+function escapeRegex(value: string): string {
+    return value.replace(/[|\\{}()[\]^$+?.]/g, "\\$&");
+}
+
+function globToRegexSource(pattern: string): string {
+    let source = "";
+    for (let index = 0; index < pattern.length; index += 1) {
+        const char = pattern[index];
+        if (char === "*") {
+            const nextChar = pattern[index + 1];
+            if (nextChar === "*") {
+                source += ".*";
+                index += 1;
+            } else {
+                source += "[^/]*";
+            }
+            continue;
+        }
+        if (char === "?") {
+            source += "[^/]";
+            continue;
+        }
+        source += escapeRegex(char);
+    }
+    return source;
+}
+
+function createGlobMatcher(pattern: string): (value: string) => boolean {
+    const normalizedPattern = toPosixPath(pattern.trim().replace(/^!+/, "").replace(/^\.\/+/, ""));
+    if (!normalizedPattern) return () => true;
+    const directRegex = new RegExp(`^${globToRegexSource(normalizedPattern)}$`);
+    const basenamePattern = normalizedPattern.includes("/")
+        ? null
+        : new RegExp(`(^|/)${globToRegexSource(normalizedPattern)}$`);
+    return (value: string) => {
+        const normalizedValue = toPosixPath(value);
+        return directRegex.test(normalizedValue) || (!!basenamePattern && basenamePattern.test(normalizedValue));
+    };
+}
+
+const excludeMatchers = EXCLUDE_GLOBS.map((pattern) => createGlobMatcher(pattern));
+
+function shouldExcludeRelativePath(relativePath: string): boolean {
+    const normalizedPath = toPosixPath(relativePath);
+    return excludeMatchers.some((matcher) => matcher(normalizedPath));
+}
+
+function listCandidateFiles(searchRoot: string, glob?: string): string[] {
+    const results: string[] = [];
+    const includeMatcher = glob ? createGlobMatcher(glob) : null;
+
+    const walk = (currentDir: string) => {
+        let entries: string[] = [];
+        try {
+            entries = readdirSync(currentDir);
+        } catch {
+            return;
+        }
+
+        for (const entry of entries) {
+            const fullPath = join(currentDir, entry);
+            const relativeToRoot = relative(ROOT, fullPath);
+            const relativeToSearchRoot = relative(searchRoot, fullPath);
+            if (shouldExcludeRelativePath(relativeToRoot) || shouldExcludeRelativePath(relativeToSearchRoot)) {
+                continue;
+            }
+
+            let stats;
+            try {
+                stats = statSync(fullPath);
+            } catch {
+                continue;
+            }
+
+            if (stats.isDirectory()) {
+                walk(fullPath);
+                continue;
+            }
+
+            if (!stats.isFile()) {
+                continue;
+            }
+
+            const normalizedRelativePath = toPosixPath(relativeToSearchRoot);
+            if (includeMatcher && !includeMatcher(normalizedRelativePath)) {
+                continue;
+            }
+
+            results.push(relativeToSearchRoot);
+        }
+    };
+
+    walk(searchRoot);
+    return results;
+}
+
+function readTextFileSafe(absPath: string): string | null {
+    let stats;
+    try {
+        stats = statSync(absPath);
+    } catch {
+        return null;
+    }
+
+    if (!stats.isFile() || stats.size > MAX_FALLBACK_FILE_BYTES) {
+        return null;
+    }
+
+    try {
+        const text = readFileSync(absPath, "utf8");
+        return text.includes("\u0000") ? null : text;
+    } catch {
+        return null;
+    }
+}
+
+function collectFallbackFileMatches(args: {
+    searchRoot: string;
+    files: string[];
+    query?: string;
+    caseSensitive: boolean;
+    maxResults: number;
+}): { files: Array<{ path: string }>; totalFiles: number; truncated: boolean } {
+    const queryText = args.query
+        ? (args.caseSensitive ? args.query : args.query.toLowerCase())
+        : null;
+    const matches: Array<{ path: string }> = [];
+    let totalFiles = 0;
+
+    for (const relativePath of args.files) {
+        if (queryText) {
+            const text = readTextFileSafe(resolve(args.searchRoot, relativePath));
+            if (text === null) continue;
+            const haystack = args.caseSensitive ? text : text.toLowerCase();
+            if (!haystack.includes(queryText)) continue;
+        }
+
+        totalFiles += 1;
+        if (matches.length < args.maxResults) {
+            matches.push({ path: toProjectRelativePath(args.searchRoot, relativePath) });
+        }
+    }
+
+    return {
+        files: matches,
+        totalFiles,
+        truncated: totalFiles > args.maxResults,
+    };
+}
+
+function collectFallbackContentMatches(args: {
+    searchRoot: string;
+    files: string[];
+    query: string;
+    caseSensitive: boolean;
+    maxResults: number;
+}): { hits: Array<{ path: string; line: number; preview: string }>; totalHits: number; truncated: boolean } {
+    const needle = args.caseSensitive ? args.query : args.query.toLowerCase();
+    const hits: Array<{ path: string; line: number; preview: string }> = [];
+    let totalHits = 0;
+
+    for (const relativePath of args.files) {
+        const text = readTextFileSafe(resolve(args.searchRoot, relativePath));
+        if (text === null) continue;
+
+        const lines = text.split(/\r?\n/);
+        for (let index = 0; index < lines.length; index += 1) {
+            const line = lines[index] ?? "";
+            const haystack = args.caseSensitive ? line : line.toLowerCase();
+            if (!haystack.includes(needle)) continue;
+
+            totalHits += 1;
+            if (hits.length < args.maxResults) {
+                hits.push({
+                    path: toProjectRelativePath(args.searchRoot, relativePath),
+                    line: index + 1,
+                    preview: line.trim(),
+                });
+            }
+        }
+    }
+
+    return {
+        hits,
+        totalHits,
+        truncated: totalHits > args.maxResults,
+    };
+}
+
+async function runRipgrepSearch(args: {
+    query?: string;
+    searchRoot: string;
+    glob?: string;
+    mode: "content" | "files";
+    caseSensitive: boolean;
+}): Promise<string[]> {
+    const rgArgs: string[] = ["--color", "never"];
+    if (!args.caseSensitive) rgArgs.push("-i");
+    for (const excludeGlob of EXCLUDE_GLOBS) {
+        rgArgs.push("-g", excludeGlob);
+    }
+    if (args.glob) {
+        rgArgs.push("-g", args.glob);
+    }
+
+    if (args.mode === "files") {
+        if (args.query) {
+            rgArgs.push("-l", args.query);
+        } else {
+            rgArgs.push("--files");
+        }
+    } else {
+        rgArgs.push("-n", "--no-heading", args.query!);
+    }
+
+    rgArgs.push(".");
+
+    let proc;
+    try {
+        proc = Bun.spawn(["rg", ...rgArgs], {
+            cwd: args.searchRoot,
+            stdout: "pipe",
+            stderr: "pipe",
+            stdin: "ignore",
+        });
+    } catch (error: any) {
+        if (
+            error?.code === "ENOENT" ||
+            error?.code === "ENOTDIR" ||
+            /not found/i.test(String(error?.message || ""))
+        ) {
+            throw new Error("RG_UNAVAILABLE");
+        }
+        throw error;
+    }
+
+    const [stdout, stderr, exitCode] = await Promise.all([
+        new Response(proc.stdout).text(),
+        new Response(proc.stderr).text(),
+        proc.exited,
+    ]);
+
+    if (exitCode > 1) {
+        throw new Error(stderr.trim() || `rg 失败，退出码 ${exitCode}`);
+    }
+
+    return stdout.split("\n").map((line) => line.trim()).filter(Boolean);
+}
+
+export async function handleCodeSearch(req: Request): Promise<Response> {
+    try {
+        if (req.method !== "POST") {
+            return new Response(JSON.stringify({ error: "Method not allowed" }), {
+                status: 405,
+                headers: { ...JSON_HEADERS, Allow: "POST, OPTIONS" },
+            });
+        }
+
+        let body: unknown;
+        try {
+            body = await req.json();
+        } catch {
+            body = {};
+        }
+
+        const {
+            query,
+            path = ".",
+            glob,
+            mode = "content",
+            maxResults,
+            caseSensitive = false,
+        }: Partial<CodeSearchRequestBody> =
+            typeof body === "object" && body !== null ? (body as any) : {};
+
+        if (typeof path !== "string") {
+            return new Response(JSON.stringify({ error: "path 必须是字符串" }), {
+                status: 400,
+                headers: JSON_HEADERS,
+            });
+        }
+        if (glob !== undefined && typeof glob !== "string") {
+            return new Response(JSON.stringify({ error: "glob 必须是字符串" }), {
+                status: 400,
+                headers: JSON_HEADERS,
+            });
+        }
+        if (mode !== "content" && mode !== "files") {
+            return new Response(JSON.stringify({ error: "mode 必须是 content 或 files" }), {
+                status: 400,
+                headers: JSON_HEADERS,
+            });
+        }
+        if (mode === "content" && (!query || typeof query !== "string")) {
+            return new Response(JSON.stringify({ error: "mode=content 时必须提供 query" }), {
+                status: 400,
+                headers: JSON_HEADERS,
+            });
+        }
+        if (query !== undefined && typeof query !== "string") {
+            return new Response(JSON.stringify({ error: "query 必须是字符串" }), {
+                status: 400,
+                headers: JSON_HEADERS,
+            });
+        }
+
+        let absSearchRoot: string;
+        try {
+            absSearchRoot = resolvePathUnderRoot(path);
+        } catch (error: any) {
+            return new Response(JSON.stringify({ error: error?.message || "path 参数无效" }), {
+                status: 400,
+                headers: JSON_HEADERS,
+            });
+        }
+
+        let safeMaxResults: number;
+        try {
+            safeMaxResults = parsePositiveInt(maxResults, 50, 200);
+        } catch (error: any) {
+            return new Response(JSON.stringify({ error: error?.message || "maxResults 参数无效" }), {
+                status: 400,
+                headers: JSON_HEADERS,
+            });
+        }
+
+        let lines: string[] | null = null;
+        let usingFallback = false;
+        try {
+            lines = await runRipgrepSearch({
+                query,
+                searchRoot: absSearchRoot,
+                glob,
+                mode,
+                caseSensitive,
+            });
+        } catch (error: any) {
+            if (error?.message !== "RG_UNAVAILABLE") {
+                throw error;
+            }
+            usingFallback = true;
+        }
+
+        if (usingFallback) {
+            const files = listCandidateFiles(absSearchRoot, glob);
+            if (mode === "files") {
+                const result = collectFallbackFileMatches({
+                    searchRoot: absSearchRoot,
+                    files,
+                    query,
+                    caseSensitive,
+                    maxResults: safeMaxResults,
+                });
+
+                return new Response(JSON.stringify({
+                    ok: true,
+                    mode,
+                    path,
+                    glob: glob ?? null,
+                    files: result.files,
+                    truncated: result.truncated,
+                    totalFiles: result.totalFiles,
+                }), { status: 200, headers: JSON_HEADERS });
+            }
+
+            const result = collectFallbackContentMatches({
+                searchRoot: absSearchRoot,
+                files,
+                query: query!,
+                caseSensitive,
+                maxResults: safeMaxResults,
+            });
+
+            return new Response(JSON.stringify({
+                ok: true,
+                mode,
+                query,
+                path,
+                glob: glob ?? null,
+                hits: result.hits,
+                truncated: result.truncated,
+                totalHits: result.totalHits,
+            }), { status: 200, headers: JSON_HEADERS });
+        }
+
+        if (mode === "files") {
+            const files = lines!.slice(0, safeMaxResults).map((filePath) => ({
+                path: toProjectRelativePath(absSearchRoot, filePath),
+            }));
+
+            return new Response(JSON.stringify({
+                ok: true,
+                mode,
+                path,
+                glob: glob ?? null,
+                files,
+                truncated: lines!.length > safeMaxResults,
+                totalFiles: lines!.length,
+            }), { status: 200, headers: JSON_HEADERS });
+        }
+
+        const hits = lines!.slice(0, safeMaxResults).flatMap((line) => {
+            const firstColon = line.indexOf(":");
+            const secondColon = line.indexOf(":", firstColon + 1);
+            if (firstColon < 0 || secondColon < 0) return [];
+
+            const relPath = toProjectRelativePath(absSearchRoot, line.slice(0, firstColon));
+            const lineNo = Number.parseInt(line.slice(firstColon + 1, secondColon), 10);
+            if (!Number.isFinite(lineNo)) return [];
+
+            return [{
+                path: relPath,
+                line: lineNo,
+                preview: line.slice(secondColon + 1).trim(),
+            }];
+        });
+
+        return new Response(JSON.stringify({
+            ok: true,
+            mode,
+            query,
+            path,
+            glob: glob ?? null,
+            hits,
+            truncated: lines!.length > safeMaxResults,
+            totalHits: lines!.length,
+        }), { status: 200, headers: JSON_HEADERS });
+    } catch (error: any) {
+        console.error("[code-search] Error:", error);
+        return new Response(
+            JSON.stringify({ error: `codeSearch 失败：${error?.message || String(error)}` }),
+            { status: 500, headers: JSON_HEADERS }
+        );
+    }
+}

package/server/handlers/connector/connectorConnectionRegistry.ts

@@ -0,0 +1,192 @@
+import { randomUUID } from "node:crypto";
+
+export type ConnectorAgentRunPayload = {
+  agentKey: string;
+  userInput: string;
+  timeoutMs?: number;
+  agentConfig?: unknown;
+  messages?: unknown[];
+  runtimeContext?: unknown;
+  spaceId?: string;
+  category?: string;
+  continueDialogId?: string;
+  meta?: unknown;
+};
+
+export type ConnectorAgentRunResult = {
+  content: string;
+  model?: string;
+  usage?: unknown;
+  trace?: unknown[];
+  diagnostics?: unknown;
+  artifacts?: unknown;
+};
+
+export type ConnectorAgentRunProgress = {
+  eventType?: "tool-call" | "tool-result" | "tool-error";
+  toolCallCount?: number;
+  toolResultCount?: number;
+  lastToolNames?: string[];
+  provider?: string;
+  promptBytes?: number;
+  promptHash?: string;
+  promptRef?: string;
+  promptPageKey?: string;
+  promptPageHash?: string;
+  requestId?: string;
+  workspaceRoot?: string;
+  workspaceKind?: string;
+  message?: string;
+  updatedAt?: number;
+};
+
+export type ConnectorAgentRunOptions = {
+  requestTimeoutMs?: number;
+  onProgress?: (progress: ConnectorAgentRunProgress) => void | Promise<void>;
+};
+
+type ConnectorSocket = {
+  send(message: string): unknown;
+};
+
+type PendingRequest = {
+  key: string;
+  machineId: string;
+  resolve: (result: ConnectorAgentRunResult) => void;
+  reject: (error: Error) => void;
+  timeout: ReturnType<typeof setTimeout>;
+  onProgress?: (progress: ConnectorAgentRunProgress) => void | Promise<void>;
+  progressTail: Promise<void>;
+};
+
+type RegisteredConnection = {
+  machineId: string;
+  ownerUserId: string;
+  receive(message: string): void;
+  close(): void;
+};
+
+function connectionKey(ownerUserId: string, machineId: string) {
+  return `${ownerUserId}:${machineId}`;
+}
+
+export function createConnectorConnectionRegistry(options: { requestTimeoutMs?: number } = {}) {
+  const connections = new Map<string, RegisteredConnection & { socket: ConnectorSocket }>();
+  const pending = new Map<string, PendingRequest>();
+  const requestTimeoutMs = options.requestTimeoutMs ?? 120_000;
+
+  const rejectPendingForConnection = (key: string, machineId: string) => {
+    for (const [requestId, request] of pending.entries()) {
+      if (request.key !== key) continue;
+      pending.delete(requestId);
+      clearTimeout(request.timeout);
+      request.reject(new Error(`Connector disconnected for machine: ${machineId}`));
+    }
+  };
+
+  const unregister = (ownerUserId: string, machineId: string) => {
+    const key = connectionKey(ownerUserId, machineId);
+    connections.delete(key);
+    rejectPendingForConnection(key, machineId);
+  };
+
+  return {
+    register(args: {
+      machineId: string;
+      ownerUserId: string;
+      send: (message: string) => unknown;
+    }): RegisteredConnection {
+      const key = connectionKey(args.ownerUserId, args.machineId);
+      const connection: RegisteredConnection & { socket: ConnectorSocket } = {
+        machineId: args.machineId,
+        ownerUserId: args.ownerUserId,
+        socket: { send: args.send },
+        receive(message) {
+          let parsed: any;
+          try {
+            parsed = JSON.parse(message);
+          } catch {
+            return;
+          }
+          if (typeof parsed?.requestId !== "string") {
+            return;
+          }
+          const request = pending.get(parsed.requestId);
+          if (!request) return;
+          if (parsed.type === "agent.run.progress") {
+            request.progressTail = request.progressTail.then(() =>
+              Promise.resolve(request.onProgress?.(parsed.progress ?? {}))
+            ).catch((error) => {
+              console.warn("[connector] agent.run.progress handler failed", error);
+            });
+            return;
+          }
+          if (parsed.type !== "agent.run.result") return;
+          pending.delete(parsed.requestId);
+          clearTimeout(request.timeout);
+          request.progressTail.then(() => {
+            if (parsed.error) {
+              request.reject(new Error(String(parsed.error)));
+              return;
+            }
+            request.resolve(parsed.result ?? { content: "" });
+          }).catch((error) => {
+            request.reject(error instanceof Error ? error : new Error(String(error)));
+          });
+        },
+        close() {
+          unregister(args.ownerUserId, args.machineId);
+        },
+      };
+      connections.set(key, connection);
+      return connection;
+    },
+
+    hasConnection(ownerUserId: string, machineId: string) {
+      return connections.has(connectionKey(ownerUserId, machineId));
+    },
+
+    unregister,
+
+    sendAgentRun(
+      ownerUserId: string,
+      machineId: string,
+      payload: ConnectorAgentRunPayload,
+      options: ConnectorAgentRunOptions = {}
+    ): Promise<ConnectorAgentRunResult> {
+      const connection = connections.get(connectionKey(ownerUserId, machineId));
+      if (!connection) {
+        return Promise.reject(new Error(`Connector offline for machine: ${machineId}`));
+      }
+      const requestId = randomUUID();
+      const effectiveRequestTimeoutMs =
+        typeof options.requestTimeoutMs === "number" &&
+        Number.isFinite(options.requestTimeoutMs) &&
+        options.requestTimeoutMs > 0
+          ? options.requestTimeoutMs
+          : requestTimeoutMs;
+      return new Promise((resolve, reject) => {
+        const timeout = setTimeout(() => {
+          pending.delete(requestId);
+          reject(new Error(`Connector request timed out for machine: ${machineId}`));
+        }, effectiveRequestTimeoutMs);
+        pending.set(requestId, {
+          key: connectionKey(ownerUserId, machineId),
+          machineId,
+          resolve,
+          reject,
+          timeout,
+          onProgress: options.onProgress,
+          progressTail: Promise.resolve(),
+        });
+        connection.socket.send(JSON.stringify({
+          type: "agent.run",
+          requestId,
+          payload,
+        }));
+      });
+    },
+  };
+}
+
+export const connectorConnectionRegistry = createConnectorConnectionRegistry();