nolo-cli 0.1.39 → 0.1.41

package/ai/agent/cliExecutor.ts

@@ -15,8 +15,8 @@
 
 import { exec, execSync, spawn } from "child_process";
 import { randomUUID } from "node:crypto";
-import { mkdtempSync, readFileSync, rmSync } from "node:fs";
-import { join } from "node:path";
+import { mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { isAbsolute, join, resolve } from "node:path";
 import { tmpdir } from "node:os";
 import { resolveLaunchableCodexCommand } from "../../connector-experimental/codexBinary";
 import { buildCliPrompt } from "./cliPrompt";
@@ -26,9 +26,22 @@ import { buildCliPrompt } from "./cliPrompt";
 /** 已支持的 CLI 工具。新增时在此联合类型追加，并在 EXECUTORS 里注册实现 */
 export type CliProvider = "copilot" | "gemini" | "codex" | "claude" | "agy";
 
+/**
+ * CLI provider 图片输入。
+ *
+ * - `source` 是原始输入（本地路径 / data URL / http URL / file URL）
+ * - `materializedPath` 是 materialize 后写入磁盘的绝对路径
+ *   （本地路径保持不变，data URL 写入临时文件，file URL 转换为本地路径）
+ * - HTTP/HTTPS URL 目前无法原生传给 CLI，只作为 prompt 引用保留
+ */
+export interface CliImageInput {
+  source: string;
+  materializedPath?: string;
+}
+
 export interface CliExecuteOptions {
   model?: string;
-  timeout?: number;   // ms，默认 120_000
+  timeout?: number;   // ms；各 CLI executor 可按任务类型设置自己的默认值
   cwd?: string;
   env?: Record<string, string | undefined>;
   yolo?: boolean;     // 允许所有工具，默认 true（后台任务常用）
@@ -41,6 +54,8 @@ export interface CliExecuteOptions {
   maxTokens?: number;
   enableThinking?: boolean;
   thinkingBudget?: number;
+  /** 图片输入（本地路径 / data URL / file URL）。materialize 由内部处理。 */
+  imageInputs?: CliImageInput[];
 }
 
 export interface CliExecuteResult {
@@ -55,6 +70,8 @@ type CliSessionMessage = {
   content: string;
 };
 
+const DEFAULT_AGY_TIMEOUT_MS = 600_000;
+
 export interface CliSessionHandle {
   sessionId: string;
   provider: CliProvider;
@@ -184,6 +201,138 @@ function shouldPassClaudeModel(options: CliExecuteOptions): boolean {
   return (options.env?.NOLO_CLAUDE_CLI_ALLOW_MODEL ?? process.env.NOLO_CLAUDE_CLI_ALLOW_MODEL) === "1";
 }
 
+// ── CLI 图片 materialize ─────────────────────────────────────────────────────
+
+const DATA_URL_RE = /^data:image\/([\w.+-]+);base64,([A-Za-z0-9+/=]+)$/;
+
+/** data URL extension (without prefix) → 完整扩展名 */
+const MIME_EXT: Record<string, string> = {
+  "png": ".png",
+  "jpeg": ".jpg",
+  "jpg": ".jpg",
+  "gif": ".gif",
+  "webp": ".webp",
+  "svg+xml": ".svg",
+  "bmp": ".bmp",
+  "tiff": ".tiff",
+  "avif": ".avif",
+};
+
+function inferExtFromMime(extPart: string): string {
+  return MIME_EXT[extPart.toLowerCase().trim()] ?? ".bin";
+}
+
+const FILE_URL_RE = /^file:\/\/(.+)$/;
+
+/**
+ * 将单个 data URL 图片写入临时文件，返回绝对路径。
+ * caller 负责在执行完后清理 tempDir。
+ */
+function writeDataUrlToTempImage(dataUrl: string, tempDir: string, index: number): string {
+  const match = dataUrl.match(DATA_URL_RE);
+  if (!match) {
+    throw new Error(`Invalid data URL format for image #${index + 1}; expected data:image/<type>;base64,<data>`);
+  }
+  const [, mimeExt, b64] = match;
+  const ext = inferExtFromMime(mimeExt);
+  const filePath = join(tempDir, `image-${index + 1}${ext}`);
+  writeFileSync(filePath, Buffer.from(b64, "base64"));
+  return filePath;
+}
+
+/**
+ * Materialize image input sources into on-disk paths where possible.
+ *
+ * - 本地 path / file URL → 解析为绝对路径，无需写临时文件
+ * - data:image/...;base64,... → 写入 tempDir 内临时文件
+ * - http(s) URL → 不做下载，保留 source 引用；materializedPath 为空
+ *
+ * 返回 `{ materialized, tempDir }`，caller 需在执行完成后 `rmSync(tempDir, { recursive: true, force: true })`。
+ * 当没有任何 data URL 时 tempDir 不会被创建，返回 null。
+ */
+export function materializeCliImageInputs(
+  imageInputs: CliImageInput[],
+  cwd: string,
+): { materialized: CliImageInput[]; tempDir: string | null } {
+  let tempDir: string | null = null;
+  const materialized = imageInputs.map((input, index) => {
+    const src = input.source.trim();
+
+    if (src.startsWith("http://") || src.startsWith("https://")) {
+      return { ...input, materializedPath: undefined };
+    }
+
+    const fileUrlMatch = src.match(FILE_URL_RE);
+    if (fileUrlMatch) {
+      const localPath = fileUrlMatch[1];
+      return {
+        ...input,
+        materializedPath: isAbsolute(localPath) ? localPath : resolve(cwd, localPath),
+      };
+    }
+
+    if (src.startsWith("data:")) {
+      if (!tempDir) {
+        tempDir = mkdtempSync(join(tmpdir(), "nolo-cli-assets-"));
+      }
+      const filePath = writeDataUrlToTempImage(src, tempDir, index);
+      return { ...input, materializedPath: filePath };
+    }
+
+    // 本地路径
+    return {
+      ...input,
+      materializedPath: isAbsolute(src) ? src : resolve(cwd, src),
+    };
+  });
+
+  return { materialized, tempDir };
+}
+
+/**
+ * 根据 provider 构建图片降级 prompt 块。
+ * Codex 使用原生 `-i` 标志，无需注入 prompt。
+ * 其他 provider 使用此函数将图片路径列表注入到 prompt 前面。
+ */
+function buildImageReferencePromptBlock(
+  provider: CliProvider,
+  materialized: CliImageInput[],
+): { promptSuffix: string; warning: string | null } {
+  const label = getCliProviderLabel(provider);
+  const localPaths = materialized
+    .filter((img) => img.materializedPath)
+    .map((img) => img.materializedPath!);
+  const httpUrls = materialized
+    .filter((img) => !img.materializedPath)
+    .map((img) => img.source);
+
+  const lines: string[] = [];
+  if (localPaths.length > 0) {
+    lines.push(
+      `[User attached image(s) - local file references (accessible at these paths):]`,
+      ...localPaths.map((p) => `  - ${p}`),
+      `Please read and analyze these image files as part of the user's request.`,
+    );
+  }
+  if (httpUrls.length > 0) {
+    lines.push(
+      `[User attached image(s) - remote URLs (content not available locally):]`,
+      ...httpUrls.map((u) => `  - ${u}`),
+      `These remote URLs could not be downloaded automatically. If you cannot access them, describe what you can infer from context.`,
+    );
+  }
+
+  const warning =
+    materialized.length > 0
+      ? `${label} image input is passed as local file references; native image flags are not available in this wrapper.`
+      : null;
+
+  return {
+    promptSuffix: lines.length > 0 ? lines.join("\n") + "\n\n" : "",
+    warning,
+  };
+}
+
 function collectCliCapabilityWarnings(
   provider: CliProvider,
   options: CliExecuteOptions
@@ -226,18 +375,51 @@ function resolveCliExecution(
   provider: CliProvider,
   prompt: string,
   options: CliExecuteOptions
-): { prompt: string; options: CliExecuteOptions; warnings: string[] } {
+): { prompt: string; options: CliExecuteOptions; warnings: string[]; imageTempDir?: string } {
   const warnings = collectCliCapabilityWarnings(provider, options);
+
+  // Handle image inputs
+  const imageInputs = options.imageInputs ?? [];
+  let resolvedPrompt = prompt;
+  let resolvedOptions = options;
+  let imageTempDir: string | undefined;
+
+  if (imageInputs.length > 0) {
+    const { materialized, tempDir } = materializeCliImageInputs(
+      imageInputs,
+      options.cwd ?? process.cwd(),
+    );
+    imageTempDir = tempDir ?? undefined;
+
+    if (provider === "codex") {
+      // Codex uses native -i flags; update options with materialized imageInputs
+      resolvedOptions = {
+        ...resolvedOptions,
+        imageInputs: materialized,
+      };
+    } else {
+      // Non-codex providers: inject image references into prompt
+      const block = buildImageReferencePromptBlock(provider, materialized);
+      if (block.promptSuffix) {
+        resolvedPrompt = block.promptSuffix + resolvedPrompt;
+      }
+      if (block.warning) {
+        warnings.push(block.warning);
+      }
+    }
+  }
+
   if (supportsNativeSystemPrompt(provider) || !options.systemPrompt?.trim()) {
-    return { prompt, options, warnings };
+    return { prompt: resolvedPrompt, options: resolvedOptions, warnings, imageTempDir };
   }
   return {
-    prompt: buildCliPrompt(options.systemPrompt, prompt),
+    prompt: buildCliPrompt(options.systemPrompt, resolvedPrompt),
     options: {
-      ...options,
+      ...resolvedOptions,
       systemPrompt: undefined,
     },
     warnings,
+    imageTempDir,
   };
 }
 
@@ -410,6 +592,11 @@ function executeCodex(
     yolo = true,
   } = options;
 
+  // Collect materialized image paths from imageInputs
+  const imagePaths = (options.imageInputs ?? [])
+    .map((img) => img.materializedPath)
+    .filter((p): p is string => Boolean(p));
+
   return new Promise((resolve, reject) => {
     const tempDir = mkdtempSync(join(tmpdir(), "codex-exec-"));
     const outputFile = join(tempDir, "last-message.txt");
@@ -429,6 +616,10 @@ function executeCodex(
       args.push("--sandbox");
       args.push("danger-full-access");
     }
+    // Add image flags for Codex CLI native image support
+    for (const imgPath of imagePaths) {
+      args.push("-i", imgPath);
+    }
     const start = Date.now();
     const proc = spawn(executable, [...args, prompt], {
       cwd,
@@ -569,12 +760,49 @@ function formatCliTimeout(timeoutMs: number) {
   return `${Math.max(1, Math.ceil(timeoutMs / 1000))}s`;
 }
 
+function tailText(value: string, maxChars = 1200): string {
+  if (value.length <= maxChars) return value;
+  return value.slice(value.length - maxChars);
+}
+
+function terminateCliProcessGroup(
+  proc: ReturnType<typeof spawn>,
+  signal: NodeJS.Signals
+) {
+  const pid = typeof proc.pid === "number" ? proc.pid : 0;
+  if (pid > 0 && process.platform !== "win32") {
+    try {
+      process.kill(-pid, signal);
+      return;
+    } catch {
+      // Fall back to the child process if the group is unavailable.
+    }
+  }
+  try {
+    proc.kill(signal);
+  } catch {
+    // Best effort cleanup only.
+  }
+}
+
+function buildAgyTimeoutError(timeout: number, stdout: string, stderr: string) {
+  const parts = [
+    `Antigravity CLI timed out after ${timeout}ms.`,
+    "agy print mode is agentic and can keep waiting for the conversation to become fully idle; prefer shorter scoped prompts or split the task into multiple turns.",
+  ];
+  const stdoutTail = tailText(stdout).trim();
+  const stderrTail = tailText(stderr).trim();
+  if (stdoutTail) parts.push(`stdout tail:\n${stdoutTail}`);
+  if (stderrTail) parts.push(`stderr tail:\n${stderrTail}`);
+  return new Error(parts.join("\n"));
+}
+
 function executeAgy(
   prompt: string,
   options: CliExecuteOptions
 ): Promise<CliExecuteResult> {
   const {
-    timeout = 120_000,
+    timeout = DEFAULT_AGY_TIMEOUT_MS,
     cwd = process.cwd(),
     yolo = true,
   } = options;
@@ -597,15 +825,28 @@ function executeAgy(
       cwd,
       env: buildCliProcessEnv(options.env),
       stdio: ["ignore", "pipe", "pipe"],
+      detached: process.platform !== "win32",
     });
     let stdout = "";
     let stderr = "";
     let timer: ReturnType<typeof setTimeout> | undefined;
+    let forceTimer: ReturnType<typeof setTimeout> | undefined;
+    let settled = false;
+
+    const clearTimers = () => {
+      if (timer) clearTimeout(timer);
+      if (forceTimer) clearTimeout(forceTimer);
+    };
 
     if (timeout > 0) {
       timer = setTimeout(() => {
-        proc.kill("SIGTERM");
-        reject(new Error(`Antigravity CLI timed out after ${timeout}ms`));
+        if (settled) return;
+        settled = true;
+        terminateCliProcessGroup(proc, "SIGTERM");
+        forceTimer = setTimeout(() => {
+          terminateCliProcessGroup(proc, "SIGKILL");
+        }, 3_000);
+        reject(buildAgyTimeoutError(timeout, stdout, stderr));
       }, timeout + 1_000);
     }
 
@@ -618,7 +859,12 @@ function executeAgy(
     });
 
     proc.on("close", (code) => {
-      if (timer) clearTimeout(timer);
+      if (settled) {
+        clearTimers();
+        return;
+      }
+      settled = true;
+      clearTimers();
       if (code !== 0 && code !== null) {
         reject(new Error(`Antigravity CLI exited with code ${code}\nstderr: ${stderr}`));
         return;
@@ -632,7 +878,9 @@ function executeAgy(
     });
 
     proc.on("error", (err) => {
-      if (timer) clearTimeout(timer);
+      if (settled) return;
+      settled = true;
+      clearTimers();
       reject(err);
     });
   });
@@ -699,11 +947,17 @@ export async function executeCli(
     throw new Error(`Unknown CLI provider: "${provider}". Supported: ${Object.keys(EXECUTORS).join(", ")}`);
   }
   const resolved = resolveCliExecution(provider, prompt, options);
-  const result = await executor(resolved.prompt, resolved.options);
-  return {
-    ...result,
-    warnings: [...resolved.warnings, ...(result.warnings ?? [])],
-  };
+  try {
+    const result = await executor(resolved.prompt, resolved.options);
+    return {
+      ...result,
+      warnings: [...resolved.warnings, ...(result.warnings ?? [])],
+    };
+  } finally {
+    if (resolved.imageTempDir) {
+      rmSync(resolved.imageTempDir, { recursive: true, force: true });
+    }
+  }
 }
 
 export { buildCliPrompt };
@@ -831,36 +1085,56 @@ export function executeCliStreaming(
 ): Promise<CliExecuteResult> {
   const resolved = resolveCliExecution(provider, prompt, options);
   const executor = EXECUTORS[provider];
+
+  const cleanupImageTempDir = () => {
+    if (resolved.imageTempDir) {
+      rmSync(resolved.imageTempDir, { recursive: true, force: true });
+    }
+  };
+
+  const withCleanup = <T>(promise: Promise<T>): Promise<T> =>
+    promise.finally(cleanupImageTempDir);
+
   if (provider === "gemini") {
-    return executeGeminiStreaming(resolved.prompt, resolved.options as CliExecuteOptions & { onChunk: (chunk: string) => void })
-      .then((result) => ({ ...result, warnings: [...resolved.warnings, ...(result.warnings ?? [])] }));
+    return withCleanup(
+      executeGeminiStreaming(resolved.prompt, resolved.options as CliExecuteOptions & { onChunk: (chunk: string) => void })
+        .then((result) => ({ ...result, warnings: [...resolved.warnings, ...(result.warnings ?? [])] }))
+    );
   }
   if (provider === "codex") {
-    return executor(resolved.prompt, resolved.options).then((result) => {
-      const merged = { ...result, warnings: [...resolved.warnings, ...(result.warnings ?? [])] };
-      if (merged.text) options.onChunk(merged.text);
-      return merged;
-    });
+    return withCleanup(
+      executor(resolved.prompt, resolved.options).then((result) => {
+        const merged = { ...result, warnings: [...resolved.warnings, ...(result.warnings ?? [])] };
+        if (merged.text) options.onChunk(merged.text);
+        return merged;
+      })
+    );
   }
   if (provider === "claude") {
-    return executor(resolved.prompt, resolved.options).then((result) => {
-      const merged = { ...result, warnings: [...resolved.warnings, ...(result.warnings ?? [])] };
-      if (merged.text) options.onChunk(merged.text);
-      return merged;
-    });
+    return withCleanup(
+      executor(resolved.prompt, resolved.options).then((result) => {
+        const merged = { ...result, warnings: [...resolved.warnings, ...(result.warnings ?? [])] };
+        if (merged.text) options.onChunk(merged.text);
+        return merged;
+      })
+    );
   }
   if (provider === "agy") {
-    return executor(resolved.prompt, resolved.options).then((result) => {
-      const merged = { ...result, warnings: [...resolved.warnings, ...(result.warnings ?? [])] };
-      if (merged.text) options.onChunk(merged.text);
-      return merged;
-    });
+    return withCleanup(
+      executor(resolved.prompt, resolved.options).then((result) => {
+        const merged = { ...result, warnings: [...resolved.warnings, ...(result.warnings ?? [])] };
+        if (merged.text) options.onChunk(merged.text);
+        return merged;
+      })
+    );
   }
   if (provider !== "copilot") {
-    return executor(resolved.prompt, resolved.options).then((result) => ({
-      ...result,
-      warnings: [...resolved.warnings, ...(result.warnings ?? [])],
-    }));
+    return withCleanup(
+      executor(resolved.prompt, resolved.options).then((result) => ({
+        ...result,
+        warnings: [...resolved.warnings, ...(result.warnings ?? [])],
+      }))
+    );
   }
 
   const {
@@ -871,7 +1145,7 @@ export function executeCliStreaming(
     onChunk,
   } = resolved.options as CliExecuteOptions & { onChunk: (chunk: string) => void };
 
-  return new Promise((resolve, reject) => {
+  return withCleanup(new Promise<CliExecuteResult>((resolve, reject) => {
     const args = [
       "copilot", "--",
       "-p", resolved.prompt,
@@ -931,7 +1205,7 @@ export function executeCliStreaming(
       if (timer) clearTimeout(timer);
       reject(err);
     });
-  });
+  }));
 }
 
 function executeGeminiStreaming(

package/ai/agent/contextCompiler.ts

@@ -0,0 +1,107 @@
+// Simple deterministic hash for cache-key purposes (browser + server compatible)
+function createHash(_algo: string) {
+  let buf = "";
+  return {
+    update(s: string) { buf += s; return this; },
+    digest(_enc: string) {
+      // FNV-1a 32-bit, hex-padded to 8 chars
+      let h = 0x811c9dc5;
+      for (let i = 0; i < buf.length; i++) {
+        h ^= buf.charCodeAt(i);
+        h = (h * 0x01000193) >>> 0;
+      }
+      return h.toString(16).padStart(8, "0");
+    },
+  };
+}
+
+export type ContextLayerOwner =
+  | "platform"
+  | "agent"
+  | "user"
+  | "runtime";
+
+export type ContextLayerCacheScope = "static" | "session" | "turn";
+
+export type ContextLayer = {
+  id: string;
+  owner: ContextLayerOwner;
+  content?: string | null;
+  tokenBudget?: number;
+  cacheScope?: ContextLayerCacheScope;
+};
+
+export type CompiledContextLayer = {
+  id: string;
+  owner: ContextLayerOwner;
+  content: string;
+  cacheScope: ContextLayerCacheScope;
+  charCount: number;
+  estimatedTokens: number;
+  tokenBudget?: number;
+  budgetStatus?: "within-budget" | "over-budget";
+};
+
+export type CompiledContext = {
+  content: string;
+  layers: CompiledContextLayer[];
+  cacheProfile: {
+    stablePrefixHash: string;
+    stablePrefixLayerIds: string[];
+    stablePrefixCharCount: number;
+    stablePrefixEstimatedTokens: number;
+  };
+};
+
+const hasLayerContent = (
+  layer: ContextLayer
+): layer is ContextLayer & { content: string } => Boolean(layer.content);
+
+export const estimateContextTokens = (content: string): number =>
+  Math.ceil(content.length / 4);
+
+export const compileContextLayers = (
+  layers: ContextLayer[]
+): CompiledContext => {
+  const compiledLayers = layers
+    .filter(hasLayerContent)
+    .map((layer): CompiledContextLayer => {
+      const estimatedTokens = estimateContextTokens(layer.content);
+      return {
+        id: layer.id,
+        owner: layer.owner,
+        content: layer.content,
+        cacheScope: layer.cacheScope ?? "turn",
+        charCount: layer.content.length,
+        estimatedTokens,
+        tokenBudget: layer.tokenBudget,
+        budgetStatus:
+          typeof layer.tokenBudget === "number"
+            ? estimatedTokens <= layer.tokenBudget
+              ? "within-budget"
+              : "over-budget"
+            : undefined,
+      };
+    });
+  const stablePrefixLayers: CompiledContextLayer[] = [];
+  for (const layer of compiledLayers) {
+    if (layer.cacheScope === "turn") break;
+    stablePrefixLayers.push(layer);
+  }
+  const stablePrefixContent = stablePrefixLayers
+    .map((layer) => layer.content)
+    .join("\n\n");
+
+  return {
+    content: compiledLayers.map((layer) => layer.content).join("\n\n"),
+    layers: compiledLayers,
+    cacheProfile: {
+      stablePrefixHash: createHash("sha256")
+        .update(stablePrefixContent)
+        .digest("hex"),
+      stablePrefixLayerIds: stablePrefixLayers.map((layer) => layer.id),
+      stablePrefixCharCount: stablePrefixContent.length,
+      stablePrefixEstimatedTokens: estimateContextTokens(stablePrefixContent),
+    },
+  };
+};

package/ai/agent/contextLayerContract.ts

@@ -0,0 +1,44 @@
+type ContextLayerContractOptions = {
+  hasRememberMemoryTool?: boolean;
+  hasDocTools?: boolean;
+};
+
+export const buildContextLayerContractBlock = (
+  options: ContextLayerContractOptions = {}
+): string => {
+  const lines = [
+    "--- 上下文分层约定 ---",
+    "不要把所有信息都塞进同一层。优先利用已有的 memory / knowledge / doc，而不是把它们混成一段长对话。",
+    "",
+    "层次边界：",
+    "1. memory layer：放短到中期、可复用但不必永久挂载的偏好、近期共识和压缩后的经验；要短、可检索、可替换。",
+    "2. knowledge layer：放稳定规则、长期有效事实和每轮都会反复依赖的说明；优先通过 prompt / references 自动加载。",
+    "3. doc layer：放需要跨轮次持续维护的外部工作台，例如 runbook、mission、incident、checkpoint、idea backlog、experiment log；需要时显式读取和更新。",
+    "",
+    "写入原则：",
+    "- 临时步骤、原始长日志、一次性思路，不要直接写进 memory 或 knowledge。",
+    "- 稳定行为规则、长期固定约束，优先沉淀到 knowledge layer。",
+    "- 用户偏好、最近形成的协作共识、近期反复有用的经验，优先沉淀到 memory layer。",
+    "- 需要跨轮次接力的任务状态、运行手册、事故记录、检查点，优先写入 doc layer。",
+    "",
+    "读取原则：",
+    "- 先用 knowledge layer 解决稳定规则问题。",
+    "- 再用 memory layer 补充近期偏好和延续性。",
+    "- 需要真实运行现场、任务状态或可共享工作台时，再读 doc layer。",
+    "- 当前用户输入始终高于 recent memory；recent memory 高于过旧的 doc 推断。",
+  ];
+
+  if (options.hasRememberMemoryTool) {
+    lines.push(
+      "- 当某条偏好、近期共识或复用经验对未来明显有帮助时，可以调用 rememberMemory，但要写成简洁可复用的一句话；只有当前 dialog 明确绑定了 space，且内容属于共享协作规则时才写 space memory。"
+    );
+  }
+
+  if (options.hasDocTools) {
+    lines.push(
+      "- 当任务需要 24h 连续运行、跨 dialog 接力或人工与 agent 共读时，优先把 mission / runbook / incident / checkpoint / idea backlog / experiment log 写入 doc layer。"
+    );
+  }
+
+  return lines.join("\n");
+};