nolo-cli 0.1.30 → 0.1.32

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/index.ts

@@ -1 +1 @@
-console.log('Hello via Bun!');
+export const test = 1;

package/authCommands.ts

@@ -9,6 +9,7 @@ import {
   loadProfileConfig,
   saveDefaultProfile,
 } from "./client/profileConfig";
+import { parseUserIdFromAuthToken } from "./cliEnvHelpers";
 import { DEFAULT_NOLO_SERVER_URL } from "./defaultServer";
 
 function getArg(args: string[], flag: string) {
@@ -67,17 +68,47 @@ async function saveTokenLogin(args: {
   configPath: string;
   serverUrl: string;
   authToken: string;
+  fetchImpl: typeof fetch;
   output: Pick<Console, "log">;
   error: Pick<Console, "error">;
 }) {
-  if (!args.authToken.trim()) {
+  const authToken = args.authToken.trim();
+  if (!authToken) {
     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: args.authToken.trim(),
+    authToken,
   });
   args.output.log(`Saved profile default -> ${args.serverUrl}`);
   return 0;
@@ -144,6 +175,7 @@ async function runWebLogin(args: {
         configPath: args.configPath,
         serverUrl: approvedServer,
         authToken: poll.token,
+        fetchImpl: args.fetchImpl,
         output: args.output,
         error: args.error,
       });
@@ -173,6 +205,7 @@ export async function runLoginCommand(args: string[], deps: LoginCommandDeps = {
       configPath,
       serverUrl,
       authToken: tokenArg,
+      fetchImpl: deps.fetchImpl ?? fetch,
       output: outputTarget,
       error: errorTarget,
     });
@@ -187,6 +220,7 @@ export async function runLoginCommand(args: string[], deps: LoginCommandDeps = {
         configPath,
         serverUrl,
         authToken,
+        fetchImpl: deps.fetchImpl ?? fetch,
         output: outputTarget,
         error: errorTarget,
       });

package/buildPublish.ts

@@ -48,6 +48,7 @@ export async function buildPublishArtifact(
   const {
     resolvedFilesToCopy,
     inlinedDeps,
+    inlinedFiles = [],
     externalDeps,
   } = await buildPublishArtifactAssembly({
     sourceDir,
@@ -72,11 +73,15 @@ export async function buildPublishArtifact(
     rootManifest
   );
 
-  if (inlinedDeps.length > 0) {
-    publishManifest.files = publishManifest.files || [];
+  if (inlinedFiles.length > 0) {
+    publishManifest.files = Array.from(new Set([...resolvedFilesToCopy, ...inlinedFiles]));
+  } else if (inlinedDeps.length > 0) {
+    publishManifest.files = Array.from(new Set(resolvedFilesToCopy));
     for (const dep of inlinedDeps) {
       publishManifest.files.push(`${dep}/**/*.ts`);
     }
+  } else {
+    publishManifest.files = Array.from(new Set(resolvedFilesToCopy));
   }
 
   if (Object.keys(externalDeps).length > 0) {