nolo-cli 0.1.32 → 0.1.34

package/ai/agent/cliExecutor.ts

@@ -14,8 +14,8 @@
  */
 
 import { exec, execSync, spawn } from "child_process";
-import { createHash, randomUUID } from "node:crypto";
-import { mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { randomUUID } from "node:crypto";
+import { mkdtempSync, readFileSync, rmSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { resolveLaunchableCodexCommand } from "../../connector-experimental/codexBinary";
@@ -50,25 +50,6 @@ 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;
@@ -190,18 +171,15 @@ 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";
+  // Codex accepts --model syntactically, but real desktop/subscription installs
+  // can fail with plan-gating errors. Keep model routing out of Codex CLI.
+  return provider !== "agy" && provider !== "codex";
 }
 
 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";
 }
@@ -217,11 +195,7 @@ function collectCliCapabilityWarnings(
     warnings.push(`${label} does not support reasoning_effort; ignored.`);
   }
 
-  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)) {
+  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."
     );
@@ -254,121 +228,16 @@ function resolveCliExecution(
   options: CliExecuteOptions
 ): { prompt: string; options: CliExecuteOptions; warnings: string[] } {
   const warnings = collectCliCapabilityWarnings(provider, options);
-  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;
-      }
-    }
+  if (supportsNativeSystemPrompt(provider) || !options.systemPrompt?.trim()) {
+    return { prompt, options, warnings };
   }
-
-  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: normalized,
-    warnings: [
-      "Antigravity CLI prompt was compacted to avoid known timeout patterns in conversation-reference and machine-permission runtime blocks.",
-    ],
+    prompt: buildCliPrompt(options.systemPrompt, prompt),
+    options: {
+      ...options,
+      systemPrompt: undefined,
+    },
+    warnings,
   };
 }
 
@@ -536,7 +405,6 @@ function executeCodex(
   options: CliExecuteOptions
 ): Promise<CliExecuteResult> {
   const {
-    model,
     timeout = 120_000,
     cwd = process.cwd(),
     yolo = true,
@@ -557,12 +425,6 @@ function executeCodex(
       "--cd",
       cwd,
     ];
-    // 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);
-    }
     if (yolo) {
       args.push("--sandbox");
       args.push("danger-full-access");
@@ -707,82 +569,9 @@ function formatCliTimeout(timeoutMs: number) {
   return `${Math.max(1, Math.ceil(timeoutMs / 1000))}s`;
 }
 
-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(
+function executeAgy(
   prompt: string,
-  options: CliExecuteOptions,
-  attempt = 0
+  options: CliExecuteOptions
 ): Promise<CliExecuteResult> {
   const {
     timeout = 120_000,
@@ -804,14 +593,6 @@ function executeAgyOnce(
     }
 
     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),
@@ -820,40 +601,12 @@ function executeAgyOnce(
     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");
-        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);
+        reject(new Error(`Antigravity CLI timed out after ${timeout}ms`));
+      }, timeout + 1_000);
     }
 
     proc.stdout.on("data", (data: Buffer) => {
@@ -866,32 +619,11 @@ function executeAgyOnce(
 
     proc.on("close", (code) => {
       if (timer) clearTimeout(timer);
-      if (timedOut) return;
       if (code !== 0 && code !== null) {
-        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);
+        reject(new Error(`Antigravity CLI exited with code ${code}\nstderr: ${stderr}`));
         return;
       }
 
-      flushDebug({
-        exitCode: code,
-        outcome: "succeeded",
-      });
       resolve({
         text: stdout.trim(),
         raw: stdout,
@@ -901,47 +633,11 @@ function executeAgyOnce(
 
     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/tools/toolNameAliases.ts

@@ -0,0 +1,70 @@
+const LEGACY_TOOL_NAME_ALIASES: Record<string, string> = {
+  createPage: "createDoc",
+  updatePage: "updateDoc",
+  update_page: "updateDoc",
+  create_page: "createDoc",
+  fetchwebpage: "fetchWebpage",
+  fetch_webpage: "fetchWebpage",
+  "fetch-page": "fetchWebpage",
+  exasearch: "exa_search",
+  "exa-search": "exa_search",
+  exa_search: "exa_search",
+  readDoc: "readDoc",
+  readpage: "readDoc",
+  read_page: "readDoc",
+  read_doc: "readDoc",
+  createdoc: "createDoc",
+  updateDocTool: "updateDoc",
+  readLocal: "readLocalFile",
+  read_local: "readLocalFile",
+  readLocalTool: "readLocalFile",
+  listLocal: "listLocalFiles",
+  list_local: "listLocalFiles",
+  terminalCommand: "execShell",
+  terminal_command: "execShell",
+  runCommand: "execShell",
+  run_command: "execShell",
+  runInBash: "execShell",
+  run_in_bash: "execShell",
+  executeCommand: "execShell",
+  execute_command: "execShell",
+};
+
+const normalizeToolName = (name: string): string =>
+  name.replace(/[-_]/g, "").toLowerCase();
+
+export const canonicalizeToolName = (rawName: string): string => {
+  const trimmedName = rawName.trim();
+  if (!trimmedName) return rawName;
+
+  if (LEGACY_TOOL_NAME_ALIASES[trimmedName]) {
+    return LEGACY_TOOL_NAME_ALIASES[trimmedName];
+  }
+
+  const normalizedRawName = normalizeToolName(trimmedName);
+  const matchedAlias = Object.entries(LEGACY_TOOL_NAME_ALIASES).find(
+    ([alias]) => normalizeToolName(alias) === normalizedRawName,
+  );
+
+  return matchedAlias?.[1] ?? trimmedName;
+};
+
+export const canonicalizeToolNames = (toolNames: string[]): string[] =>
+  Array.from(
+    new Set(
+      toolNames
+        .filter((toolName): toolName is string => typeof toolName === "string")
+        .map(canonicalizeToolName),
+    ),
+  );
+
+export const prioritizeToolNames = (
+  toolNames: string[],
+  preferredToolNames: string[],
+): string[] => {
+  const canonicalTools = canonicalizeToolNames(toolNames);
+  const preferred = new Set(canonicalizeToolNames(preferredToolNames));
+  const prioritized = canonicalTools.filter((toolName) => preferred.has(toolName));
+  const remaining = canonicalTools.filter((toolName) => !preferred.has(toolName));
+  return [...prioritized, ...remaining];
+};

package/authCommands.ts

@@ -9,7 +9,6 @@ import {
   loadProfileConfig,
   saveDefaultProfile,
 } from "./client/profileConfig";
-import { parseUserIdFromAuthToken } from "./cliEnvHelpers";
 import { DEFAULT_NOLO_SERVER_URL } from "./defaultServer";
 
 function getArg(args: string[], flag: string) {
@@ -68,47 +67,17 @@ async function saveTokenLogin(args: {
   configPath: string;
   serverUrl: string;
   authToken: string;
-  fetchImpl: typeof fetch;
   output: Pick<Console, "log">;
   error: Pick<Console, "error">;
 }) {
-  const authToken = args.authToken.trim();
-  if (!authToken) {
+  if (!args.authToken.trim()) {
     args.error.error("No auth token provided.");
     return 1;
   }
 
-  const userId = parseUserIdFromAuthToken(authToken);
-  if (!userId) {
-    args.error.error("Auth token payload is missing userId.");
-    return 1;
-  }
-
-  try {
-    const res = await args.fetchImpl(
-      `${args.serverUrl}/api/v1/db/query/${encodeURIComponent(userId)}?limit=1`,
-      {
-        method: "POST",
-        headers: {
-          Authorization: `Bearer ${authToken}`,
-          "Content-Type": "application/json",
-        },
-        body: JSON.stringify({ type: "agent" }),
-      }
-    );
-    if (res.status === 401 || res.status === 403) {
-      args.error.error(
-        `Auth token is not valid for ${args.serverUrl}. Log in against the matching server or use a token issued by that server.`
-      );
-      return 1;
-    }
-  } catch {
-    // Allow saving when the server is temporarily unreachable.
-  }
-
   saveDefaultProfile(args.configPath, {
     serverUrl: args.serverUrl,
-    authToken,
+    authToken: args.authToken.trim(),
   });
   args.output.log(`Saved profile default -> ${args.serverUrl}`);
   return 0;
@@ -175,7 +144,6 @@ async function runWebLogin(args: {
         configPath: args.configPath,
         serverUrl: approvedServer,
         authToken: poll.token,
-        fetchImpl: args.fetchImpl,
         output: args.output,
         error: args.error,
       });
@@ -205,7 +173,6 @@ export async function runLoginCommand(args: string[], deps: LoginCommandDeps = {
       configPath,
       serverUrl,
       authToken: tokenArg,
-      fetchImpl: deps.fetchImpl ?? fetch,
       output: outputTarget,
       error: errorTarget,
     });
@@ -220,7 +187,6 @@ export async function runLoginCommand(args: string[], deps: LoginCommandDeps = {
         configPath,
         serverUrl,
         authToken,
-        fetchImpl: deps.fetchImpl ?? fetch,
         output: outputTarget,
         error: errorTarget,
       });