farming-code 2.2.29 → 2.2.30

package/config/farming.deploy.env.example

@@ -10,4 +10,4 @@ FARMING_REMOTE_BASE_PATH=/farming
 # FARMING_REMOTE_CONFIG_DIR=/home/user/.farming
 # FARMING_REMOTE_SERVER_HOME=/home/user
 
-# 应用内升级源在 Web Settings 中配置，并保存到远端 FARMING_REMOTE_CONFIG_DIR/settings.json。
+# 源码部署使用对应的手动部署流程；应用内更新只对 npm 安装开放。

package/config/farming.install.env.example

@@ -11,7 +11,7 @@ FARMING_BASE_PATH=/farming
 # 可选：为 demo 或共享机器隔离 server 进程的 HOME。
 # FARMING_SERVER_HOME="${HOME}"
 
-# 应用内升级源在 Web Settings 中配置，并保存到 ~/.farming/settings.json。
+# 应用内更新只对 npm 安装开放；App Bundle 使用对应的手动部署流程。
 
 # Farming 随发行包提供默认公共 npm 镜像候选。
 # 可设置为其他 HTTPS Registry Origin，或设置为 off 关闭镜像候选。

package/dist/acp/codex-acp-1.1.4.mjs

@@ -23366,6 +23366,9 @@ function createAgentTextThoughtChunk(text, messageId, meta3) {
 var LEGACY_SET_SESSION_MODEL_METHOD = "session/set_model";
 var GOAL_CONTROL_METHOD = "_codex/session/goal_control";
 var STEER_METHOD = "_codex/session/steer";
+var SUBAGENT_STATE_VERSION = 1;
+var MAX_SUBAGENT_THREADS = 128;
+var SUBAGENT_READ_CONCURRENCY = 8;
 function isExtMethodRequest(request) {
   return request.method === "authentication/status" || request.method === "authentication/logout" || request.method === LEGACY_SET_SESSION_MODEL_METHOD || request.method === GOAL_CONTROL_METHOD || request.method === STEER_METHOD;
 }
@@ -26124,6 +26127,54 @@ var CodexAcpClient = class {
     const response = await this.codexClient.threadGoalGet({ threadId: sessionId });
     return response?.goal ?? null;
   }
+  onClientTransportEvent(callback) {
+    this.codexClient.onClientTransportEvent(callback);
+  }
+  async listSubagentThreads(rootThreadId) {
+    const threads = [];
+    let cursor = null;
+    do {
+      const response = await this.codexClient.threadList({
+        cursor,
+        limit: Math.min(100, MAX_SUBAGENT_THREADS - threads.length),
+        sortKey: "created_at",
+        sortDirection: "asc",
+        useStateDbOnly: true,
+        ancestorThreadId: rootThreadId
+      });
+      threads.push(...response.data.slice(0, MAX_SUBAGENT_THREADS - threads.length));
+      cursor = threads.length < MAX_SUBAGENT_THREADS ? response.nextCursor ?? null : null;
+    } while (cursor);
+    let nextIndex = 0;
+    const resolved = new Array(threads.length);
+    const worker = async () => {
+      while (nextIndex < threads.length) {
+        const index = nextIndex++;
+        const thread = threads[index];
+        const runtimeStatus = thread?.status?.type;
+        if (runtimeStatus === "active" || runtimeStatus === "systemError") {
+          resolved[index] = thread;
+          continue;
+        }
+        try {
+          const response = await this.codexClient.threadRead({
+            threadId: thread.id,
+            includeTurns: true
+          });
+          resolved[index] = response.thread;
+        } catch {
+          resolved[index] = thread;
+        }
+      }
+    };
+    await Promise.all(
+      Array.from(
+        { length: Math.min(SUBAGENT_READ_CONCURRENCY, threads.length) },
+        () => worker()
+      )
+    );
+    return resolved.filter(Boolean);
+  }
   async setGoal(sessionId, objective, onTurnStarted) {
     return await this.codexClient.runGoalSet({
       threadId: sessionId,
@@ -27372,6 +27423,53 @@ function imageBlocks(images) {
     return path6 ? [{ type: "text", text: `[@image](${path6})` }] : [];
   });
 }
+var MAX_HISTORY_IMAGE_BYTES = 5 * 1024 * 1024;
+var HISTORY_IMAGE_MIME_BY_EXT = /* @__PURE__ */ new Map([
+  [".gif", "image/gif"],
+  [".jpeg", "image/jpeg"],
+  [".jpg", "image/jpeg"],
+  [".png", "image/png"],
+  [".svg", "image/svg+xml"],
+  [".webp", "image/webp"]
+]);
+function historyImageBlockFromDataUrl(value) {
+  const match = String(value ?? "").match(/^data:(image\/(?:gif|jpe?g|png|svg\+xml|webp));base64,([a-z0-9+/=]+)$/i);
+  if (!match || Math.ceil(match[2].length * 3 / 4) > MAX_HISTORY_IMAGE_BYTES) {
+    return null;
+  }
+  return {
+    type: "image",
+    mimeType: match[1].toLowerCase(),
+    data: match[2]
+  };
+}
+async function historyImageBlockFromLocalPath(value) {
+  let filePath = String(value ?? "");
+  if (filePath.startsWith("file://")) {
+    try {
+      filePath = fileURLToPath(filePath);
+    } catch {
+      return null;
+    }
+  }
+  const mimeType = HISTORY_IMAGE_MIME_BY_EXT.get(path5.extname(filePath).toLowerCase());
+  if (!mimeType) {
+    return null;
+  }
+  try {
+    const data = await readFile2(filePath);
+    if (data.length === 0 || data.length > MAX_HISTORY_IMAGE_BYTES) {
+      return null;
+    }
+    return {
+      type: "image",
+      mimeType,
+      data: Buffer2.from(data).toString("base64")
+    };
+  } catch {
+    return null;
+  }
+}
 function contentBlocksFromResponseContent(content) {
   if (!Array.isArray(content)) {
     return [];
@@ -28171,6 +28269,13 @@ var CodexAcpServer = class _CodexAcpServer {
   closingSessions;
   sessionGenerations;
   sessionOpenGenerations;
+  subagentSnapshots;
+  subagentRootByThreadId;
+  subagentRefreshTokens;
+  subagentPublishQueues;
+  subagentPublishDirty;
+  subagentRecoveryTimers;
+  subagentRecoveryAttempts;
   constructor(connection, codexAcpClient, defaultAuthRequest, getExitCode, getRecentStderr) {
     this.sessions = /* @__PURE__ */ new Map();
     this.pendingMcpStartupSessions = /* @__PURE__ */ new Map();
@@ -28179,6 +28284,13 @@ var CodexAcpServer = class _CodexAcpServer {
     this.closingSessions = /* @__PURE__ */ new Map();
     this.sessionGenerations = /* @__PURE__ */ new Map();
     this.sessionOpenGenerations = /* @__PURE__ */ new Map();
+    this.subagentSnapshots = /* @__PURE__ */ new Map();
+    this.subagentRootByThreadId = /* @__PURE__ */ new Map();
+    this.subagentRefreshTokens = /* @__PURE__ */ new Map();
+    this.subagentPublishQueues = /* @__PURE__ */ new Map();
+    this.subagentPublishDirty = /* @__PURE__ */ new Set();
+    this.subagentRecoveryTimers = /* @__PURE__ */ new Map();
+    this.subagentRecoveryAttempts = /* @__PURE__ */ new Map();
     this.connection = connection;
     this.codexAcpClient = codexAcpClient;
     this.defaultAuthRequest = defaultAuthRequest ?? null;
@@ -28194,6 +28306,9 @@ var CodexAcpServer = class _CodexAcpServer {
       (operation) => this.runWithProcessCheck(operation),
       () => this.refreshSessionsAuthState(null)
     );
+    this.codexAcpClient.onClientTransportEvent((event) => {
+      this.handleSubagentTransportEvent(event);
+    });
   }
   async initialize(_params) {
     logger.log("Initialize request received");
@@ -28234,7 +28349,8 @@ var CodexAcpServer = class _CodexAcpServer {
         },
         _meta: {
           codex: {
-            steer: { method: STEER_METHOD, version: 1 }
+            steer: { method: STEER_METHOD, version: 1 },
+            subagents: { version: SUBAGENT_STATE_VERSION }
           }
         }
       },
@@ -28513,6 +28629,7 @@ You have been logged out. Please try again.`);
       thread
     } = await this.getOrCreateSessionWithHistory(params);
     await this.streamThreadHistory(sessionId, thread);
+    this.refreshSubagentSnapshotAsync(sessionId);
     logger.log("Session loaded", {
       sessionId,
       modelId: modelState.currentModelId,
@@ -28548,6 +28665,7 @@ You have been logged out. Please try again.`);
       modelId: modelState.currentModelId,
       availableModelCount: modelState.availableModels.length
     });
+    this.refreshSubagentSnapshotAsync(sessionId);
     return {
       models: modelState,
       modes: modeState,
@@ -28589,6 +28707,7 @@ You have been logged out. Please try again.`);
         await activePrompt.completion;
       }
       await this.runWithProcessCheck(() => this.codexAcpClient.closeSession(params.sessionId));
+      this.clearSubagentSnapshot(params.sessionId);
       logger.log("Session closed", { sessionId: params.sessionId });
     } finally {
       if (this.getSessionGeneration(params.sessionId) === closeGeneration) {
@@ -28601,6 +28720,256 @@ You have been logged out. Please try again.`);
     }
     return {};
   }
+  clearSubagentSnapshot(rootThreadId) {
+    const snapshot = this.subagentSnapshots.get(rootThreadId);
+    for (const threadId of snapshot?.agents.keys() ?? []) {
+      if (this.subagentRootByThreadId.get(threadId) === rootThreadId) {
+        this.subagentRootByThreadId.delete(threadId);
+      }
+    }
+    this.subagentSnapshots.delete(rootThreadId);
+    this.subagentRefreshTokens.delete(rootThreadId);
+    this.subagentPublishQueues.delete(rootThreadId);
+    this.subagentPublishDirty.delete(rootThreadId);
+    const recoveryTimer = this.subagentRecoveryTimers.get(rootThreadId);
+    if (recoveryTimer) clearTimeout(recoveryTimer);
+    this.subagentRecoveryTimers.delete(rootThreadId);
+    this.subagentRecoveryAttempts.delete(rootThreadId);
+  }
+  rootThreadIdForSubagent(threadId) {
+    if (this.sessions.has(threadId)) return threadId;
+    return this.subagentRootByThreadId.get(threadId) ?? null;
+  }
+  subagentStatusFromThread(thread) {
+    const runtimeStatus = thread?.status?.type;
+    if (runtimeStatus === "active") return "running";
+    if (runtimeStatus === "systemError") return "errored";
+    const lastTurn = Array.isArray(thread?.turns) ? thread.turns.at(-1) : null;
+    switch (lastTurn?.status) {
+      case "completed":
+        return "completed";
+      case "interrupted":
+        return "interrupted";
+      case "failed":
+        return "errored";
+      case "inProgress":
+        return "running";
+      default:
+        return "pendingInit";
+    }
+  }
+  subagentSnapshotEntry(thread) {
+    return {
+      threadId: String(thread.id),
+      parentThreadId: typeof thread.parentThreadId === "string" ? thread.parentThreadId : null,
+      name: typeof thread.agentNickname === "string" && thread.agentNickname.trim()
+        ? thread.agentNickname.trim()
+        : typeof thread.agentRole === "string" && thread.agentRole.trim()
+          ? thread.agentRole.trim()
+          : "",
+      status: this.subagentStatusFromThread(thread)
+    };
+  }
+  refreshSubagentSnapshotAsync(rootThreadId) {
+    const refreshToken = this.subagentRefreshTokens.get(rootThreadId) ?? 0;
+    void this.runWithProcessCheck(() => this.codexAcpClient.listSubagentThreads(rootThreadId)).then((threads) => {
+      if (!this.sessions.has(rootThreadId)) return;
+      if ((this.subagentRefreshTokens.get(rootThreadId) ?? 0) !== refreshToken) {
+        this.refreshSubagentSnapshotAsync(rootThreadId);
+        return;
+      }
+      const previous = this.subagentSnapshots.get(rootThreadId);
+      const agents = new Map(
+        threads.map((thread) => {
+          const entry = this.subagentSnapshotEntry(thread);
+          return [entry.threadId, entry];
+        })
+      );
+      for (const threadId of previous?.agents.keys() ?? []) {
+        if (!agents.has(threadId) && this.subagentRootByThreadId.get(threadId) === rootThreadId) {
+          this.subagentRootByThreadId.delete(threadId);
+        }
+      }
+      for (const threadId of agents.keys()) {
+        this.subagentRootByThreadId.set(threadId, rootThreadId);
+      }
+      const snapshot = {
+        revision: (previous?.revision ?? 0) + 1,
+        agents
+      };
+      this.subagentSnapshots.set(rootThreadId, snapshot);
+      this.publishSubagentUpdate(rootThreadId, "snapshot", [...agents.values()], snapshot.revision);
+    }).catch((error51) => {
+      logger.error(`Failed to reconcile Codex subagents for session ${rootThreadId}`, error51);
+    });
+  }
+  publishSubagentUpdate(rootThreadId, kind, agents, revision) {
+    if (!this.sessions.has(rootThreadId)) return;
+    const run = async () => {
+      const dirty = this.subagentPublishDirty.has(rootThreadId);
+      const current = this.subagentSnapshots.get(rootThreadId);
+      const updateKind = dirty ? "snapshot" : kind;
+      const updateAgents = dirty && current ? [...current.agents.values()] : agents;
+      const updateRevision = dirty && current ? current.revision : revision;
+      const session = new ACPSessionConnection(this.connection, rootThreadId);
+      await session.update({
+        sessionUpdate: "session_info_update",
+        _meta: {
+          codex: {
+            subagents: {
+              version: SUBAGENT_STATE_VERSION,
+              rootThreadId,
+              revision: updateRevision,
+              kind: updateKind,
+              agents: updateAgents
+            }
+          }
+        }
+      });
+      this.subagentPublishDirty.delete(rootThreadId);
+      this.subagentRecoveryAttempts.delete(rootThreadId);
+      const recoveryTimer = this.subagentRecoveryTimers.get(rootThreadId);
+      if (recoveryTimer) clearTimeout(recoveryTimer);
+      this.subagentRecoveryTimers.delete(rootThreadId);
+    };
+    const previous = this.subagentPublishQueues.get(rootThreadId);
+    const next = (previous ? previous.then(run, run) : run()).catch((error51) => {
+      logger.error(`Failed to publish Codex subagent state for session ${rootThreadId}`, error51);
+      this.subagentPublishDirty.add(rootThreadId);
+      this.scheduleSubagentRecovery(rootThreadId);
+    });
+    this.subagentPublishQueues.set(rootThreadId, next);
+    void next.finally(() => {
+      if (this.subagentPublishQueues.get(rootThreadId) === next) {
+        this.subagentPublishQueues.delete(rootThreadId);
+      }
+    });
+  }
+  scheduleSubagentRecovery(rootThreadId) {
+    if (!this.sessions.has(rootThreadId) || this.subagentRecoveryTimers.has(rootThreadId)) return;
+    const attempt = this.subagentRecoveryAttempts.get(rootThreadId) ?? 0;
+    if (attempt >= 3) return;
+    const delays = [100, 500, 1e3];
+    const timer = setTimeout(() => {
+      this.subagentRecoveryTimers.delete(rootThreadId);
+      if (!this.sessions.has(rootThreadId)) {
+        this.subagentPublishDirty.delete(rootThreadId);
+        this.subagentRecoveryAttempts.delete(rootThreadId);
+        return;
+      }
+      if (!this.subagentPublishDirty.has(rootThreadId)) return;
+      this.subagentRecoveryAttempts.set(rootThreadId, attempt + 1);
+      const current = this.subagentSnapshots.get(rootThreadId);
+      if (!current) return;
+      this.publishSubagentUpdate(
+        rootThreadId,
+        "snapshot",
+        [...current.agents.values()],
+        current.revision
+      );
+    }, delays[attempt]);
+    this.subagentRecoveryTimers.set(rootThreadId, timer);
+  }
+  updateSubagent(rootThreadId, entry) {
+    if (!rootThreadId || !entry?.threadId || !this.sessions.has(rootThreadId)) return;
+    const previous = this.subagentSnapshots.get(rootThreadId) ?? {
+      revision: 0,
+      agents: /* @__PURE__ */ new Map()
+    };
+    const existing = previous.agents.get(entry.threadId);
+    const nextEntry = {
+      threadId: entry.threadId,
+      parentThreadId: entry.parentThreadId ?? existing?.parentThreadId ?? null,
+      name: entry.name ?? existing?.name ?? "",
+      status: entry.status ?? existing?.status ?? "pendingInit"
+    };
+    if (
+      existing
+      && existing.parentThreadId === nextEntry.parentThreadId
+      && existing.name === nextEntry.name
+      && existing.status === nextEntry.status
+    ) {
+      return;
+    }
+    const next = {
+      revision: previous.revision + 1,
+      agents: new Map(previous.agents)
+    };
+    next.agents.set(nextEntry.threadId, nextEntry);
+    this.subagentSnapshots.set(rootThreadId, next);
+    this.subagentRootByThreadId.set(nextEntry.threadId, rootThreadId);
+    this.subagentRefreshTokens.set(
+      rootThreadId,
+      (this.subagentRefreshTokens.get(rootThreadId) ?? 0) + 1
+    );
+    this.publishSubagentUpdate(rootThreadId, "delta", [nextEntry], next.revision);
+  }
+  handleSubagentTransportEvent(event) {
+    if (event?.eventType !== "notification") return;
+    const params = event.params ?? {};
+    const method = event.method;
+    if (method === "thread/started") {
+      const thread = params.thread;
+      const parentThreadId = thread?.parentThreadId;
+      const rootThreadId = typeof parentThreadId === "string"
+        ? this.rootThreadIdForSubagent(parentThreadId)
+        : null;
+      if (rootThreadId && thread?.id) {
+        this.updateSubagent(rootThreadId, this.subagentSnapshotEntry(thread));
+      }
+      return;
+    }
+    if (
+      (method === "item/started" || method === "item/completed")
+      && params.item?.type === "subAgentActivity"
+    ) {
+      const parentThreadId = typeof params.threadId === "string" ? params.threadId : "";
+      const rootThreadId = this.rootThreadIdForSubagent(parentThreadId);
+      const childThreadId = params.item.threadId;
+      if (rootThreadId && typeof childThreadId === "string") {
+        this.updateSubagent(rootThreadId, {
+          threadId: childThreadId,
+          parentThreadId,
+          status: "pendingInit"
+        });
+      }
+      return;
+    }
+    const threadId = typeof params.threadId === "string" ? params.threadId : "";
+    const rootThreadId = this.rootThreadIdForSubagent(threadId);
+    if (!rootThreadId || rootThreadId === threadId) return;
+    if (method === "turn/started") {
+      this.updateSubagent(rootThreadId, { threadId, status: "running" });
+      return;
+    }
+    if (method === "turn/completed") {
+      const status = params.turn?.status;
+      this.updateSubagent(rootThreadId, {
+        threadId,
+        status: status === "completed"
+          ? "completed"
+          : status === "interrupted"
+            ? "interrupted"
+            : status === "failed"
+              ? "errored"
+              : "running"
+      });
+      return;
+    }
+    if (method === "thread/status/changed") {
+      const status = params.status?.type;
+      if (status === "active" || status === "systemError") {
+        this.updateSubagent(rootThreadId, {
+          threadId,
+          status: status === "active" ? "running" : "errored"
+        });
+      }
+      return;
+    }
+    if (method === "thread/closed") {
+      this.updateSubagent(rootThreadId, { threadId, status: "shutdown" });
+    }
+  }
   async deleteSession(params) {
     logger.log("Deleting session...", { sessionId: params.sessionId });
     const sessionId = params.sessionId;
@@ -29107,11 +29476,11 @@ You have been logged out. Please try again.`);
         return [this.createPlanUpdate(item)];
     }
   }
-  createUserMessageUpdates(item) {
+  async createUserMessageUpdates(item) {
     const updates = [];
     const messageId = item.id;
     for (const input of item.content) {
-      const blocks = this.userInputToContentBlocks(input);
+      const blocks = await this.userInputToContentBlocks(input);
       for (const block of blocks) {
         updates.push(createUserMessageChunk(block, messageId));
       }
@@ -29155,15 +29524,26 @@ ${item.text}`
       }
     };
   }
-  userInputToContentBlocks(input) {
+  async userInputToContentBlocks(input) {
     switch (input.type) {
       case "text":
         return input.text.length > 0 ? [{ type: "text", text: input.text }] : [];
-      case "image":
-        return [{ type: "text", text: this.formatUriAsLink("image", input.url) }];
+      case "image": {
+        const image = historyImageBlockFromDataUrl(input.url);
+        return image ? [image] : [{
+          type: "resource_link",
+          uri: input.url,
+          name: "image"
+        }];
+      }
       case "localImage": {
         const uri = input.path.startsWith("file://") ? input.path : `file://${input.path}`;
-        return [{ type: "text", text: this.formatUriAsLink(null, uri) }];
+        const image = await historyImageBlockFromLocalPath(input.path);
+        return image ? [image] : [{
+          type: "resource_link",
+          uri,
+          name: path5.basename(input.path) || "image"
+        }];
       }
       case "skill":
         return [{ type: "text", text: `skill:${input.name} (${input.path})` }];