nolo-cli 0.1.30 → 0.1.31

package/ai/agent/cliExecutor.ts

@@ -14,8 +14,8 @@
  */
 
 import { exec, execSync, spawn } from "child_process";
-import { randomUUID } from "node:crypto";
-import { mkdtempSync, readFileSync, rmSync } from "node:fs";
+import { createHash, randomUUID } from "node:crypto";
+import { mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { resolveLaunchableCodexCommand } from "../../connector-experimental/codexBinary";
@@ -50,6 +50,25 @@ export interface CliExecuteResult {
   warnings?: string[];
 }
 
+type AgyDebugArtifact = {
+  dir: string;
+  promptHash: string;
+  promptBytes: number;
+  writeResult: (args: {
+    startedAt: string;
+    finishedAt: string;
+    elapsedMs: number;
+    cwd: string;
+    timeoutMs: number;
+    args: string[];
+    stdout: string;
+    stderr: string;
+    exitCode: number | null;
+    outcome: "succeeded" | "timed_out" | "spawn_error" | "failed";
+    errorMessage?: string;
+  }) => void;
+};
+
 type CliSessionMessage = {
   role: "user" | "assistant";
   content: string;
@@ -171,6 +190,8 @@ function supportsNativeSystemPrompt(provider: CliProvider): boolean {
 }
 
 function supportsModel(provider: CliProvider): boolean {
+  // Antigravity CLI does not expose a model selection flag.
+  // Codex is handled separately so explicit opt-in can still pass --model through.
   return provider !== "agy";
 }
 
@@ -178,6 +199,13 @@ function supportsReasoningEffort(provider: CliProvider): boolean {
   return provider === "claude" || provider === "copilot";
 }
 
+function shouldPassCodexModel(options: CliExecuteOptions): boolean {
+  return (options.env?.NOLO_CODEX_CLI_ALLOW_MODEL ?? process.env.NOLO_CODEX_CLI_ALLOW_MODEL) === "1";
+}
+function shouldPassClaudeModel(options: CliExecuteOptions): boolean {
+  return (options.env?.NOLO_CLAUDE_CLI_ALLOW_MODEL ?? process.env.NOLO_CLAUDE_CLI_ALLOW_MODEL) === "1";
+}
+
 function collectCliCapabilityWarnings(
   provider: CliProvider,
   options: CliExecuteOptions
@@ -189,7 +217,15 @@ function collectCliCapabilityWarnings(
     warnings.push(`${label} does not support reasoning_effort; ignored.`);
   }
 
-  if (options.model !== undefined && !supportsModel(provider)) {
+  if (provider === "codex" && options.model !== undefined && !shouldPassCodexModel(options)) {
+    warnings.push(
+      "Codex CLI model selection is disabled by default because real Codex installs can reject --model with subscription/plan errors; set NOLO_CODEX_CLI_ALLOW_MODEL=1 to pass it through."
+    );
+  } else if (provider === "claude" && options.model !== undefined && !shouldPassClaudeModel(options)) {
+    warnings.push(
+      "Claude CLI model selection is disabled by default because current installs can reject --model; set NOLO_CLAUDE_CLI_ALLOW_MODEL=1 to pass it through."
+    );
+  } else if (options.model !== undefined && !supportsModel(provider)) {
     warnings.push(`${label} does not support model selection; ignored.`);
   }
 
@@ -218,16 +254,121 @@ function resolveCliExecution(
   options: CliExecuteOptions
 ): { prompt: string; options: CliExecuteOptions; warnings: string[] } {
   const warnings = collectCliCapabilityWarnings(provider, options);
-  if (supportsNativeSystemPrompt(provider) || !options.systemPrompt?.trim()) {
-    return { prompt, options, warnings };
+  const resolvedPrompt =
+    supportsNativeSystemPrompt(provider) || !options.systemPrompt?.trim()
+      ? prompt
+      : buildCliPrompt(options.systemPrompt, prompt);
+  const resolvedOptions =
+    supportsNativeSystemPrompt(provider) || !options.systemPrompt?.trim()
+      ? options
+      : {
+          ...options,
+          systemPrompt: undefined,
+        };
+  const agyPrompt = provider === "agy" ? compactAgyPrompt(resolvedPrompt) : null;
+  return {
+    prompt: agyPrompt?.prompt ?? resolvedPrompt,
+    options: resolvedOptions,
+    warnings: [...warnings, ...(agyPrompt?.warnings ?? [])],
+  };
+}
+
+const AGY_PRESERVED_PROMPT_BLOCK_HEADERS = [
+  "--- Nolo read-only CLI bridge ---",
+  "--- Nolo task-run tool bridge ---",
+] as const;
+const AGY_OPTIONAL_TASKRUN_GUIDANCE_HEADERS = [
+  "## TaskRun tool guidance (2026-05-17)",
+  "## TaskRun tool strictness (2026-05-17)",
+  "## TaskRun delegation boundary (2026-05-17)",
+] as const;
+
+function escapeRegExp(value: string) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+function extractPromptBlock(source: string, header: string) {
+  const pattern = new RegExp(
+    `(?:^|\\n)(${escapeRegExp(header)}\\n[\\s\\S]*?)(?=\\n{2,}--- [^\\n]+ ---|\\n{2,}User task:|\\n{2,}--- User task ---|$)`,
+  );
+  const match = source.match(pattern);
+  if (!match) return null;
+  return {
+    block: match[1].trim(),
+    remaining: source.replace(pattern, "\n\n"),
+  };
+}
+
+function stripMarkdownSection(source: string, header: string) {
+  const pattern = new RegExp(
+    `(?:^|\\n)${escapeRegExp(header)}\\n[\\s\\S]*?(?=\\n{2,}## [^\\n]+|\\n{2,}--- [^\\n]+ ---|\\n{2,}User task:|\\n{2,}--- User task ---|$)`,
+  );
+  return source.replace(pattern, "\n\n");
+}
+
+function compactAgyPrompt(prompt: string): { prompt: string; warnings: string[] } {
+  let next = prompt;
+  let changed = false;
+  const preservedBlocks: string[] = [];
+
+  const stripBlock = (pattern: RegExp) => {
+    const updated = next.replace(pattern, "\n\n");
+    if (updated !== next) {
+      next = updated;
+      changed = true;
+    }
+  };
+
+  for (const header of AGY_PRESERVED_PROMPT_BLOCK_HEADERS) {
+    const extracted = extractPromptBlock(next, header);
+    if (!extracted) continue;
+    next = extracted.remaining;
+    preservedBlocks.push(extracted.block);
+    changed = true;
+  }
+
+  // Antigravity intermittently stalls on long runtime metadata tails. The
+  // connector already enforces permissions and owns dialog context, so trim
+  // these blocks before handing the prompt to agy.
+  stripBlock(/(?:^|\n)Conversation Reference:\n[\s\S]*?(?=\n{2,}--- Machine permission policy ---|\n{2,}--- User task ---|\n{2,}User task:|$)/);
+  stripBlock(/(?:^|\n)--- Machine permission policy ---\n[\s\S]*?(?=\n{2,}--- User task ---|\n{2,}User task:|$)/);
+  if (!preservedBlocks.some((block) => block.startsWith("--- Nolo task-run tool bridge ---"))) {
+    for (const header of AGY_OPTIONAL_TASKRUN_GUIDANCE_HEADERS) {
+      const updated = stripMarkdownSection(next, header);
+      if (updated !== next) {
+        next = updated;
+        changed = true;
+      }
+    }
+  }
+
+  let normalized = next
+    .replace(/\n\n--- User task ---\n/g, "\n\nUser task:\n")
+    .replace(/\n{3,}/g, "\n\n")
+    .trim();
+  if (preservedBlocks.length > 0) {
+    const reinjected = preservedBlocks.join("\n\n");
+    if (/^User task:\n/.test(normalized)) {
+      normalized = `${reinjected}\n\n${normalized}`;
+    } else if (/\n\nUser task:\n/.test(normalized)) {
+      normalized = normalized.replace(/\n\nUser task:\n/, `\n\n${reinjected}\n\nUser task:\n`);
+    } else {
+      normalized = `${normalized}\n\n${reinjected}`.trim();
+    }
   }
+  if (normalized !== prompt) {
+    changed = true;
+  }
+
+  if (!changed) {
+    return { prompt, warnings: [] };
+  }
+
   return {
-    prompt: buildCliPrompt(options.systemPrompt, prompt),
-    options: {
-      ...options,
-      systemPrompt: undefined,
-    },
-    warnings,
+    prompt: normalized,
+    warnings: [
+      "Antigravity CLI prompt was compacted to avoid known timeout patterns in conversation-reference and machine-permission runtime blocks.",
+    ],
   };
 }
 
@@ -416,7 +557,9 @@ function executeCodex(
       "--cd",
       cwd,
     ];
-    if (model) {
+    // Codex CLI accepts --model syntactically, but real desktop/subscription
+    // installs can fail with plan-gating errors. Keep default execution stable.
+    if (model && shouldPassCodexModel(options)) {
       args.push("--model");
       args.push(model);
     }
@@ -496,8 +639,8 @@ function executeClaude(
   } = options;
 
   return new Promise((resolve, reject) => {
-    const args = ["-p", prompt];
-    if (model) {
+    const args = ["--add-dir", cwd, "-p", prompt];
+    if (model && shouldPassClaudeModel(options)) {
       args.push("--model");
       args.push(model);
     }
@@ -564,9 +707,82 @@ function formatCliTimeout(timeoutMs: number) {
   return `${Math.max(1, Math.ceil(timeoutMs / 1000))}s`;
 }
 
-function executeAgy(
+function shortHash(value: string) {
+  return createHash("sha256").update(value).digest("hex").slice(0, 12);
+}
+
+function resolveAgyDebugDir(env?: Record<string, string | undefined>) {
+  const raw = env?.NOLO_AGY_DEBUG_DIR ?? process.env.NOLO_AGY_DEBUG_DIR ?? "";
+  return raw.trim();
+}
+
+function createAgyDebugArtifact(args: {
+  prompt: string;
+  attempt: number;
+  timeoutMs: number;
+  cwd: string;
+  env?: Record<string, string | undefined>;
+}): AgyDebugArtifact | null {
+  const debugRoot = resolveAgyDebugDir(args.env);
+  if (!debugRoot) return null;
+
+  const promptHash = shortHash(args.prompt);
+  const promptBytes = Buffer.byteLength(args.prompt, "utf8");
+  const dir = join(debugRoot, `${Date.now()}-agy-${promptHash}-attempt-${args.attempt + 1}`);
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(join(dir, "prompt.txt"), args.prompt, "utf8");
+
+  return {
+    dir,
+    promptHash,
+    promptBytes,
+    writeResult: (result) => {
+      writeFileSync(join(dir, "stdout.txt"), result.stdout, "utf8");
+      writeFileSync(join(dir, "stderr.txt"), result.stderr, "utf8");
+      writeFileSync(
+        join(dir, "meta.json"),
+        `${JSON.stringify({
+          promptHash,
+          promptBytes,
+          attempt: args.attempt + 1,
+          startedAt: result.startedAt,
+          finishedAt: result.finishedAt,
+          elapsedMs: result.elapsedMs,
+          cwd: result.cwd,
+          timeoutMs: result.timeoutMs,
+          args: result.args,
+          exitCode: result.exitCode,
+          outcome: result.outcome,
+          errorMessage: result.errorMessage ?? null,
+          stdoutBytes: Buffer.byteLength(result.stdout, "utf8"),
+          stderrBytes: Buffer.byteLength(result.stderr, "utf8"),
+        }, null, 2)}\n`,
+        "utf8"
+      );
+    },
+  };
+}
+
+function isAgyTimeoutError(error: unknown) {
+  return error instanceof Error && /Antigravity CLI timed out after \d+ms/.test(error.message);
+}
+
+function resolveAgyTimeoutRetryCount(env?: Record<string, string | undefined>) {
+  const raw = env?.NOLO_AGY_TIMEOUT_RETRIES ?? process.env.NOLO_AGY_TIMEOUT_RETRIES ?? "2";
+  const parsed = Number.parseInt(raw, 10);
+  return Number.isFinite(parsed) && parsed >= 0 ? parsed : 2;
+}
+
+const AGY_PROCESS_TIMEOUT_BUFFER_MS = 10_000;
+
+function isAgyUpstreamTimeoutText(stdout: string) {
+  return /^Error:\s+timed out waiting for response\b/i.test(stdout.trim());
+}
+
+function executeAgyOnce(
   prompt: string,
-  options: CliExecuteOptions
+  options: CliExecuteOptions,
+  attempt = 0
 ): Promise<CliExecuteResult> {
   const {
     timeout = 120_000,
@@ -576,6 +792,8 @@ function executeAgy(
 
   return new Promise((resolve, reject) => {
     const args = [
+      "--add-dir",
+      cwd,
       "--print",
       prompt,
       "--print-timeout",
@@ -586,6 +804,14 @@ function executeAgy(
     }
 
     const start = Date.now();
+    const startedAt = new Date(start).toISOString();
+    const debugArtifact = createAgyDebugArtifact({
+      prompt,
+      attempt,
+      timeoutMs: timeout,
+      cwd,
+      env: options.env,
+    });
     const proc = spawn("agy", args, {
       cwd,
       env: buildCliProcessEnv(options.env),
@@ -594,12 +820,40 @@ function executeAgy(
     let stdout = "";
     let stderr = "";
     let timer: ReturnType<typeof setTimeout> | undefined;
+    let timedOut = false;
+
+    const flushDebug = (result: {
+      exitCode: number | null;
+      outcome: "succeeded" | "timed_out" | "spawn_error" | "failed";
+      errorMessage?: string;
+    }) => {
+      debugArtifact?.writeResult({
+        startedAt,
+        finishedAt: new Date().toISOString(),
+        elapsedMs: Date.now() - start,
+        cwd,
+        timeoutMs: timeout,
+        args,
+        stdout,
+        stderr,
+        exitCode: result.exitCode,
+        outcome: result.outcome,
+        ...(result.errorMessage ? { errorMessage: result.errorMessage } : {}),
+      });
+    };
 
     if (timeout > 0) {
       timer = setTimeout(() => {
+        timedOut = true;
         proc.kill("SIGTERM");
-        reject(new Error(`Antigravity CLI timed out after ${timeout}ms`));
-      }, timeout + 1_000);
+        const error = new Error(`Antigravity CLI timed out after ${timeout}ms`);
+        flushDebug({
+          exitCode: null,
+          outcome: "timed_out",
+          errorMessage: error.message,
+        });
+        reject(error);
+      }, timeout + AGY_PROCESS_TIMEOUT_BUFFER_MS);
     }
 
     proc.stdout.on("data", (data: Buffer) => {
@@ -612,11 +866,32 @@ function executeAgy(
 
     proc.on("close", (code) => {
       if (timer) clearTimeout(timer);
+      if (timedOut) return;
       if (code !== 0 && code !== null) {
-        reject(new Error(`Antigravity CLI exited with code ${code}\nstderr: ${stderr}`));
+        const error = new Error(`Antigravity CLI exited with code ${code}\nstderr: ${stderr}`);
+        flushDebug({
+          exitCode: code,
+          outcome: "failed",
+          errorMessage: error.message,
+        });
+        reject(error);
+        return;
+      }
+      if (isAgyUpstreamTimeoutText(stdout)) {
+        const error = new Error(`Antigravity CLI timed out after ${timeout}ms`);
+        flushDebug({
+          exitCode: code,
+          outcome: "timed_out",
+          errorMessage: error.message,
+        });
+        reject(error);
         return;
       }
 
+      flushDebug({
+        exitCode: code,
+        outcome: "succeeded",
+      });
       resolve({
         text: stdout.trim(),
         raw: stdout,
@@ -626,11 +901,47 @@ function executeAgy(
 
     proc.on("error", (err) => {
       if (timer) clearTimeout(timer);
+      flushDebug({
+        exitCode: null,
+        outcome: "spawn_error",
+        errorMessage: err instanceof Error ? err.message : String(err),
+      });
       reject(err);
     });
   });
 }
 
+async function executeAgy(
+  prompt: string,
+  options: CliExecuteOptions
+): Promise<CliExecuteResult> {
+  const maxRetries = resolveAgyTimeoutRetryCount(options.env);
+  let attempt = 0;
+  let lastError: unknown;
+
+  while (attempt <= maxRetries) {
+    try {
+      const result = await executeAgyOnce(prompt, options, attempt);
+      if (attempt === 0) return result;
+      return {
+        ...result,
+        warnings: [
+          ...(result.warnings ?? []),
+          `Antigravity CLI succeeded after ${attempt} timeout retr${attempt === 1 ? "y" : "ies"}.`,
+        ],
+      };
+    } catch (error) {
+      lastError = error;
+      if (!isAgyTimeoutError(error) || attempt >= maxRetries) {
+        throw error;
+      }
+      attempt += 1;
+    }
+  }
+
+  throw lastError instanceof Error ? lastError : new Error(String(lastError));
+}
+
 // ── 注册表（新增 CLI 工具时在这里加） ────────────────────────────────────────
 
 const EXECUTORS: Record<

package/ai/agent/createAgentSchema.ts

@@ -35,6 +35,17 @@ const referenceItemSchema = z
     type: data.type === "page" ? "knowledge" : data.type,
   }));
 
+const isLocalProviderUrl = (value?: string | null) => {
+  const normalized = typeof value === "string" ? value.trim() : "";
+  if (!normalized) return false;
+  try {
+    const hostname = new URL(normalized).hostname.toLowerCase();
+    return hostname === "127.0.0.1" || hostname === "localhost" || hostname === "::1";
+  } catch {
+    return false;
+  }
+};
+
 // --- 核心 schema ---
 export const getCreateAgentSchema = (t: TFunction) =>
   z
@@ -222,6 +233,17 @@ export const getCreateAgentSchema = (t: TFunction) =>
         message: t("validation.modelRequired"),
         path: ["model"],
       }
+    )
+    .refine(
+      (data) => {
+        if (!data.machineId?.trim()) return true;
+        if (data.apiSource === "cli") return true;
+        return data.apiSource === "custom" && isLocalProviderUrl(data.customProviderUrl);
+      },
+      {
+        message: t("validation.machineBindingRequiresCliOrLocalCustom"),
+        path: ["machineId"],
+      }
     );
 
 export type FormData = z.infer<ReturnType<typeof getCreateAgentSchema>>;

package/ai/agent/hooks/fetchPublicAgents.ts

@@ -2,27 +2,18 @@ import { getDb } from "../../../database/client/db";
 import { pino } from "pino";
 import { pubAgentKeys } from "../../../database/keys";
 import { Agent } from "../../../app/types";
-import { supportsImageGeneration } from "../../agent/utils/imageOutput";
 import { getRecordTimestamp, isTombstoneRecord } from "../../../database/tombstones";
+import {
+  filterPublicAgentRecords,
+  preparePublicAgentCatalogRecords,
+  type PublicAgentFilterOptions,
+  type PublicAgentListOptions,
+} from "../../agent/publicAgentCatalog";
 import { buildSortMeta, sortAgents } from "../../agent/utils/sortUtils";
 
 const logger = pino({ name: "fetchPublicAgents" });
 
-interface FetchPublicAgentsOptions {
-  limit?: number;
-  sortBy?:
-  | "recommended"
-  | "newest"
-  | "popular"
-  | "rating"
-  | "outputPriceAsc"
-  | "outputPriceDesc"
-  | "favorite";
-  searchName?: string;
-  userId?: string;
-  imageOutputOnly?: boolean;
-  toolName?: string;
-}
+interface FetchPublicAgentsOptions extends PublicAgentFilterOptions, PublicAgentListOptions {}
 
 interface PublicAgentTombstone {
   id?: string;
@@ -57,7 +48,7 @@ export async function fetchPublicAgents(
     let tombstones: PublicAgentTombstone[] = [];
 
     const db = getDb();
-    if (!db) return { data: [], total: 0, hasMore: false };
+    if (!db) return { data: [], total: 0, hasMore: false, tombstones: [] };
 
     for (const { start, end } of ranges) {
       const iterator = await db.iterator({
@@ -73,28 +64,12 @@ export async function fetchPublicAgents(
         results.push(value as Agent);
       }
     }
-
-    if (searchName) {
-      const kw = searchName.toLowerCase();
-      results = results.filter((agent) =>
-        agent.name?.toLowerCase().includes(kw)
-      );
-    }
-
-    if (userId) {
-      results = results.filter((agent) => agent.userId === userId);
-    }
-
-    if (imageOutputOnly) {
-      results = results.filter((agent) => supportsImageGeneration(agent));
-    }
-
-    if (toolName) {
-      const kw = toolName.toLowerCase();
-      results = results.filter((agent) =>
-        agent.tools?.some((t) => t.toLowerCase().includes(kw))
-      );
-    }
+    results = filterPublicAgentRecords(preparePublicAgentCatalogRecords(results), {
+      searchName,
+      userId,
+      imageOutputOnly,
+      toolName,
+    });
 
     results = sortAgents(
       results.map((agent) => ({