ai-project-manage-cli 8.1.11 → 8.1.13

package/dist/worker-script.js

@@ -1996,6 +1996,14 @@ var MinioClient = class {
   async removeObject(bucket, objectKey) {
     await this.inner.removeObject(bucket, objectKey);
   }
+  async getObjectBuffer(bucket, objectKey) {
+    const stream = await this.inner.getObject(bucket, objectKey);
+    const chunks = [];
+    for await (const chunk of stream) {
+      chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+    }
+    return Buffer.concat(chunks);
+  }
 };
 
 // src/commands/connect/apm-log-minio.ts
@@ -2460,6 +2468,76 @@ function createPtySessionMcpServers(cfg2) {
 }
 
 // src/commands/connect/remote-local-agent-store.ts
+import { createHash as createHash2 } from "node:crypto";
+import {
+  existsSync as existsSync5,
+  mkdirSync as mkdirSync4,
+  readFileSync as readFileSync4,
+  rmSync,
+  unlinkSync,
+  writeFileSync as writeFileSync3
+} from "node:fs";
+import { dirname as dirname2, join as join4 } from "node:path";
+var INLINE_CHECKPOINT_MAX_BYTES = 256 * 1024;
+var CHECKPOINT_CACHE_DIR = join4(APM_CONFIG_DIR, "cursor-checkpoint-cache");
+function checkpointObjectKey(agentId, blobId) {
+  return `cursor-agents/${agentId}/checkpoints/${blobId}`;
+}
+function safeBlobFileName(blobId) {
+  if (/^[a-zA-Z0-9._-]+$/.test(blobId)) return blobId;
+  return createHash2("sha256").update(blobId).digest("hex");
+}
+function checkpointCachePath(agentId, blobId) {
+  return join4(CHECKPOINT_CACHE_DIR, agentId, safeBlobFileName(blobId));
+}
+function checkpointCacheKey(agentId, blobId) {
+  return `${agentId}\0${blobId}`;
+}
+function readLocalCheckpoint(agentId, blobId) {
+  try {
+    const path3 = checkpointCachePath(agentId, blobId);
+    if (!existsSync5(path3)) return null;
+    return new Uint8Array(readFileSync4(path3));
+  } catch {
+    return null;
+  }
+}
+function writeLocalCheckpoint(agentId, blobId, data) {
+  try {
+    const path3 = checkpointCachePath(agentId, blobId);
+    mkdirSync4(dirname2(path3), { recursive: true });
+    writeFileSync3(path3, Buffer.from(data));
+  } catch (err) {
+    console.warn(
+      `[apm] checkpoint \u672C\u5730\u7F13\u5B58\u5199\u5165\u5931\u8D25 agentId=${agentId} blobId=${blobId}:`,
+      err instanceof Error ? err.message : err
+    );
+  }
+}
+function deleteLocalCheckpoint(agentId, blobId) {
+  try {
+    const path3 = checkpointCachePath(agentId, blobId);
+    if (existsSync5(path3)) unlinkSync(path3);
+  } catch {
+  }
+}
+function clearLocalCheckpointCache(agentId) {
+  try {
+    if (agentId?.trim()) {
+      const dir = join4(CHECKPOINT_CACHE_DIR, agentId.trim());
+      if (existsSync5(dir)) rmSync(dir, { recursive: true, force: true });
+      return;
+    }
+    if (existsSync5(CHECKPOINT_CACHE_DIR)) {
+      rmSync(CHECKPOINT_CACHE_DIR, { recursive: true, force: true });
+    }
+  } catch (err) {
+    console.warn(
+      `[apm] \u6E05\u7406 checkpoint \u672C\u5730\u7F13\u5B58\u5931\u8D25:`,
+      err instanceof Error ? err.message : err
+    );
+  }
+}
 function asCheckpointRef(value) {
   if (value === void 0) return void 0;
   if (value === null) return null;
@@ -2534,6 +2612,25 @@ function base64ToBytes(dataBase64) {
 }
 function createRemoteLocalAgentStore(cfg2) {
   const api = createApmApiClient(cfg2);
+  let minioCache = null;
+  const memoryCheckpointCache = /* @__PURE__ */ new Map();
+  function getMinio() {
+    if (!minioCache) {
+      minioCache = createApmLogMinioClient(cfg2).then(({ client, bucket }) => ({
+        client,
+        bucket
+      }));
+    }
+    return minioCache;
+  }
+  function rememberCheckpoint(agentId, blobId, data) {
+    memoryCheckpointCache.set(checkpointCacheKey(agentId, blobId), data);
+    writeLocalCheckpoint(agentId, blobId, data);
+  }
+  function forgetCheckpoint(agentId, blobId) {
+    memoryCheckpointCache.delete(checkpointCacheKey(agentId, blobId));
+    deleteLocalCheckpoint(agentId, blobId);
+  }
   async function upsertAgent(agent) {
     const row = await api.cli.cursorStoreUpsertAgent({
       agentId: agent.agentId,
@@ -2570,13 +2667,58 @@ function createRemoteLocalAgentStore(cfg2) {
     return fromApiRun(row);
   }
   async function putCheckpoint(input) {
+    const createdAt = Date.now();
+    if (input.data.byteLength > INLINE_CHECKPOINT_MAX_BYTES) {
+      const { client, bucket } = await getMinio();
+      const objectKey = checkpointObjectKey(input.agentId, input.blobId);
+      await client.putObject(bucket, objectKey, Buffer.from(input.data), {
+        "Content-Type": "application/octet-stream"
+      });
+      await api.cli.cursorStorePutCheckpoint({
+        agentId: input.agentId,
+        blobId: input.blobId,
+        objectKey,
+        byteSize: input.data.byteLength,
+        createdAt
+      });
+      rememberCheckpoint(input.agentId, input.blobId, input.data);
+      return;
+    }
     await api.cli.cursorStorePutCheckpoint({
       agentId: input.agentId,
       blobId: input.blobId,
       dataBase64: bytesToBase64(input.data),
       byteSize: input.data.byteLength,
-      createdAt: Date.now()
+      createdAt
     });
+    rememberCheckpoint(input.agentId, input.blobId, input.data);
+  }
+  async function readCheckpointBytes(input) {
+    const memKey = checkpointCacheKey(input.agentId, input.blobId);
+    const cached = memoryCheckpointCache.get(memKey);
+    if (cached) return cached;
+    const local = readLocalCheckpoint(input.agentId, input.blobId);
+    if (local) {
+      memoryCheckpointCache.set(memKey, local);
+      return local;
+    }
+    const row = await api.cli.cursorStoreGetCheckpoint({
+      agentId: input.agentId,
+      blobId: input.blobId
+    });
+    if (!row) return null;
+    let bytes = null;
+    if (row.dataBase64) {
+      bytes = base64ToBytes(row.dataBase64);
+    } else {
+      const objectKey = row.objectKey?.trim();
+      if (!objectKey) return null;
+      const { client, bucket } = await getMinio();
+      const buf = await client.getObjectBuffer(bucket, objectKey);
+      bytes = new Uint8Array(buf);
+    }
+    rememberCheckpoint(input.agentId, input.blobId, bytes);
+    return bytes;
   }
   return {
     agents: {
@@ -2732,12 +2874,7 @@ function createRemoteLocalAgentStore(cfg2) {
     },
     checkpoints: {
       async get(input) {
-        const row = await api.cli.cursorStoreGetCheckpoint({
-          agentId: input.agentId,
-          blobId: input.blobId
-        });
-        if (!row?.dataBase64) return null;
-        return base64ToBytes(row.dataBase64);
+        return readCheckpointBytes(input);
       },
       async create(input) {
         await putCheckpoint(input);
@@ -2750,6 +2887,23 @@ function createRemoteLocalAgentStore(cfg2) {
         const blobIds = input.filter.blobIds?.map((id) => id.trim()).filter(Boolean);
         if (agentIds && agentIds.length > 0 || blobIds && blobIds.length > 0) {
           await api.cli.cursorStoreDeleteCheckpoints({ agentIds, blobIds });
+          if (agentIds && agentIds.length > 0 && !blobIds?.length) {
+            for (const id of agentIds) clearLocalCheckpointCache(id);
+          } else if (agentIds && blobIds) {
+            for (const id of agentIds) {
+              for (const blobId of blobIds) forgetCheckpoint(id, blobId);
+            }
+          } else if (blobIds) {
+            for (const blobId of blobIds) {
+              for (const key of memoryCheckpointCache.keys()) {
+                const sep2 = key.indexOf("\0");
+                if (sep2 < 0) continue;
+                if (key.slice(sep2 + 1) === blobId) {
+                  forgetCheckpoint(key.slice(0, sep2), blobId);
+                }
+              }
+            }
+          }
           return;
         }
         let cursor;
@@ -2766,6 +2920,8 @@ function createRemoteLocalAgentStore(cfg2) {
           if (!page.nextCursor) break;
           cursor = page.nextCursor;
         }
+        clearLocalCheckpointCache();
+        memoryCheckpointCache.clear();
       },
       async list(input) {
         const page = await api.cli.cursorStoreListCheckpoints({
@@ -3180,14 +3336,14 @@ function createThrottledWebIdeMessageLogSync(cfg2, ctx, onError, options) {
 
 // src/commands/sync-webide-agent.ts
 import {
-  existsSync as existsSync5,
-  mkdirSync as mkdirSync4,
+  existsSync as existsSync6,
+  mkdirSync as mkdirSync5,
   readdirSync as readdirSync3,
-  readFileSync as readFileSync4,
-  unlinkSync,
-  writeFileSync as writeFileSync3
+  readFileSync as readFileSync5,
+  unlinkSync as unlinkSync2,
+  writeFileSync as writeFileSync4
 } from "fs";
-import { join as join4 } from "path";
+import { join as join5 } from "path";
 var REVISION_FILE = ".webide-agent.json";
 var RULE_KEY = /^[a-z0-9_]+$/;
 function withTrailingNewline(text) {
@@ -3195,10 +3351,10 @@ function withTrailingNewline(text) {
 `;
 }
 function readRevision(apmDir) {
-  const path3 = toFsPath(join4(apmDir, REVISION_FILE));
-  if (!existsSync5(path3)) return null;
+  const path3 = toFsPath(join5(apmDir, REVISION_FILE));
+  if (!existsSync6(path3)) return null;
   try {
-    const parsed = JSON.parse(readFileSync4(path3, "utf8"));
+    const parsed = JSON.parse(readFileSync5(path3, "utf8"));
     if (parsed?.version === 1 && parsed.revision?.trim()) {
       return parsed.revision.trim();
     }
@@ -3208,8 +3364,8 @@ function readRevision(apmDir) {
   return null;
 }
 function writeRevision(apmDir, revision) {
-  writeFileSync3(
-    toFsPath(join4(apmDir, REVISION_FILE)),
+  writeFileSync4(
+    toFsPath(join5(apmDir, REVISION_FILE)),
     `${JSON.stringify({ version: 1, revision }, null, 2)}
 `,
     "utf8"
@@ -3223,14 +3379,14 @@ async function syncWebIdeAgentFiles(workdir, cfg2) {
     throw new Error("[apm] \u5E73\u53F0\u672A\u8FD4\u56DE WebIDE \u89C4\u5219\u7248\u672C");
   }
   const apmDir = workspaceApmDir(workdir);
-  mkdirSync4(toFsPath(apmDir), { recursive: true });
+  mkdirSync5(toFsPath(apmDir), { recursive: true });
   if (readRevision(apmDir) === revision) {
     return { revision, wrote: false, ruleCount: bundle.rules?.length ?? 0 };
   }
-  const rulesDir = join4(apmDir, "rules");
-  mkdirSync4(toFsPath(rulesDir), { recursive: true });
-  writeFileSync3(
-    toFsPath(join4(apmDir, "AGENTS.md")),
+  const rulesDir = join5(apmDir, "rules");
+  mkdirSync5(toFsPath(rulesDir), { recursive: true });
+  writeFileSync4(
+    toFsPath(join5(apmDir, "AGENTS.md")),
     withTrailingNewline(bundle.guide ?? ""),
     "utf8"
   );
@@ -3241,8 +3397,8 @@ async function syncWebIdeAgentFiles(workdir, cfg2) {
       throw new Error(`[apm] \u975E\u6CD5\u89C4\u5219\u540D: ${key || "(\u7A7A)"}`);
     }
     keep.add(`${key}.md`);
-    writeFileSync3(
-      toFsPath(join4(rulesDir, `${key}.md`)),
+    writeFileSync4(
+      toFsPath(join5(rulesDir, `${key}.md`)),
       withTrailingNewline(rule.body ?? ""),
       "utf8"
     );
@@ -3250,7 +3406,7 @@ async function syncWebIdeAgentFiles(workdir, cfg2) {
   for (const name of readdirSync3(toFsPath(rulesDir))) {
     if (!name.endsWith(".md")) continue;
     if (keep.has(name)) continue;
-    unlinkSync(toFsPath(join4(rulesDir, name)));
+    unlinkSync2(toFsPath(join5(rulesDir, name)));
   }
   writeRevision(apmDir, revision);
   return {
@@ -3275,14 +3431,14 @@ async function ensureWorkspaceInitialized(workdir) {
 
 // src/utils/project-documents.ts
 import {
-  existsSync as existsSync6,
+  existsSync as existsSync7,
   readdirSync as readdirSync4,
-  readFileSync as readFileSync5,
-  rmSync,
-  writeFileSync as writeFileSync4
+  readFileSync as readFileSync6,
+  rmSync as rmSync2,
+  writeFileSync as writeFileSync5
 } from "fs";
-import { createHash as createHash2 } from "crypto";
-import { dirname as dirname2, join as join5, relative as relative4, sep } from "path";
+import { createHash as createHash3 } from "crypto";
+import { dirname as dirname3, join as join6, relative as relative4, sep } from "path";
 var MANIFEST_FILE = "manifest.json";
 function normalizeProjectIdForPath(projectId) {
   const id = projectId.trim();
@@ -3296,11 +3452,11 @@ function normalizeProjectIdForPath(projectId) {
 }
 function projectDocumentsDir(apmRoot, projectId) {
   const id = normalizeProjectIdForPath(projectId);
-  return join5(apmRoot ?? workspaceApmDir(), "project", id);
+  return join6(apmRoot ?? workspaceApmDir(), "project", id);
 }
 function projectDocumentLocalPath(apmRoot, projectId, documentPath) {
   const normalized = normalizeLocalDocumentPath(documentPath);
-  return join5(
+  return join6(
     projectDocumentsDir(apmRoot, projectId),
     ...normalized.split("/")
   );
@@ -3317,19 +3473,19 @@ function normalizeLocalDocumentPath(path3) {
   return segments.join("/");
 }
 function hashLocalFileContent(content) {
-  return createHash2("sha256").update(content, "utf8").digest("hex");
+  return createHash3("sha256").update(content, "utf8").digest("hex");
 }
 function readLocalManifest(apmRoot, projectId) {
-  const manifestPath2 = join5(
+  const manifestPath2 = join6(
     projectDocumentsDir(apmRoot, projectId),
     MANIFEST_FILE
   );
-  if (!existsSync6(manifestPath2)) {
+  if (!existsSync7(manifestPath2)) {
     return null;
   }
   try {
     return JSON.parse(
-      readFileSync5(manifestPath2, "utf8")
+      readFileSync6(manifestPath2, "utf8")
     );
   } catch {
     return null;
@@ -3337,13 +3493,13 @@ function readLocalManifest(apmRoot, projectId) {
 }
 function listLocalDocumentPaths(apmRoot, projectId) {
   const root = projectDocumentsDir(apmRoot, projectId);
-  if (!existsSync6(root)) {
+  if (!existsSync7(root)) {
     return [];
   }
   const paths = [];
   const walk = (dir) => {
     for (const entry of readdirSync4(dir, { withFileTypes: true })) {
-      const abs = join5(dir, entry.name);
+      const abs = join6(dir, entry.name);
       if (entry.isDirectory()) {
         walk(abs);
         continue;
@@ -3462,8 +3618,8 @@ ${diagnostic ?? ""}`);
       const absPath = toFsPath(
         projectDocumentLocalPath(targetApmDir, projectId, doc.path)
       );
-      await ensureDirExists(dirname2(absPath));
-      writeFileSync4(absPath, doc.content, "utf8");
+      await ensureDirExists(dirname3(absPath));
+      writeFileSync5(absPath, doc.content, "utf8");
       downloaded += 1;
     }
   }
@@ -3472,13 +3628,13 @@ ${diagnostic ?? ""}`);
     const absPath = toFsPath(
       projectDocumentLocalPath(targetApmDir, projectId, path3)
     );
-    if (existsSync6(absPath)) {
-      rmSync(absPath, { force: true });
+    if (existsSync7(absPath)) {
+      rmSync2(absPath, { force: true });
       deleted += 1;
     }
   }
-  writeFileSync4(
-    toFsPath(join5(docsDir, MANIFEST_FILE)),
+  writeFileSync5(
+    toFsPath(join6(docsDir, MANIFEST_FILE)),
     `${JSON.stringify(remoteManifest, null, 2)}
 `,
     "utf8"
@@ -3521,7 +3677,7 @@ async function syncProjectDocumentsPush(cfg2, workdirPath, apmRoot, options) {
     const absPath = toFsPath(
       projectDocumentLocalPath(targetApmDir, projectId, path3)
     );
-    const content = readFileSync5(absPath, "utf8");
+    const content = readFileSync6(absPath, "utf8");
     const contentHash = hashLocalFileContent(content);
     if (remoteHashByPath.get(path3) === contentHash) {
       continue;
@@ -4006,18 +4162,18 @@ async function handleStartProject(cfg2, msg2, signal) {
 }
 
 // src/commands/connect/webide-agent-registry.ts
-import { existsSync as existsSync7, mkdirSync as mkdirSync5, readFileSync as readFileSync6, writeFileSync as writeFileSync5 } from "node:fs";
-import { dirname as dirname3, resolve as resolve6 } from "node:path";
+import { existsSync as existsSync8, mkdirSync as mkdirSync6, readFileSync as readFileSync7, writeFileSync as writeFileSync6 } from "node:fs";
+import { dirname as dirname4, resolve as resolve6 } from "node:path";
 function registryPath(workdir, taskId, fileName = "cursor-agent.json") {
   return resolve6(workdir, ".apm", "webide", taskId, fileName);
 }
 var DESIGN_AGENT_FILE = "design-agent.json";
 function readRegistry(path3) {
-  if (!existsSync7(path3)) {
+  if (!existsSync8(path3)) {
     return {};
   }
   try {
-    const parsed = JSON.parse(readFileSync6(path3, "utf8"));
+    const parsed = JSON.parse(readFileSync7(path3, "utf8"));
     if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
       const raw = parsed;
       const state = {};
@@ -4046,8 +4202,8 @@ function readRegistry(path3) {
   return {};
 }
 function writeRegistry(path3, registry) {
-  mkdirSync5(dirname3(path3), { recursive: true });
-  writeFileSync5(path3, `${JSON.stringify(registry, null, 2)}
+  mkdirSync6(dirname4(path3), { recursive: true });
+  writeFileSync6(path3, `${JSON.stringify(registry, null, 2)}
 `, "utf8");
 }
 function syncWebIdeTaskState(workdir, taskId, patch) {
@@ -4088,7 +4244,7 @@ function saveWebIdeAgentId(workdir, taskId, agentId) {
 }
 function clearWebIdeAgentId(workdir, taskId) {
   const path3 = registryPath(workdir, taskId);
-  if (!existsSync7(path3)) return;
+  if (!existsSync8(path3)) return;
   syncWebIdeTaskState(workdir, taskId, { agentId: "" });
 }
 function loadWebIdeDesignAgentId(workdir, taskId) {
@@ -4108,7 +4264,7 @@ function saveWebIdeDesignAgentId(workdir, taskId, agentId) {
 }
 function clearWebIdeDesignAgentId(workdir, taskId) {
   const path3 = registryPath(workdir, taskId, DESIGN_AGENT_FILE);
-  if (!existsSync7(path3)) return;
+  if (!existsSync8(path3)) return;
   const current = readRegistry(path3);
   const next = { ...current };
   delete next.agentId;
@@ -4120,7 +4276,7 @@ function clearWebIdeDesignAgentId(workdir, taskId) {
 }
 
 // src/commands/clean-webide-cache.ts
-import { existsSync as existsSync8, rmSync as rmSync2 } from "node:fs";
+import { existsSync as existsSync9, rmSync as rmSync3 } from "node:fs";
 import { resolve as resolve7 } from "node:path";
 async function purgeCursorAgentStoreForAgent(cfg2, agentId) {
   const trimmedAgentId = agentId.trim();
@@ -4147,6 +4303,7 @@ async function purgeCursorAgentStoreForAgent(cfg2, agentId) {
   await store.runs.delete({ filter: { agentIds: [trimmedAgentId] } });
   await store.checkpoints.delete({ filter: { agentIds: [trimmedAgentId] } });
   await store.agents.delete({ filter: { agentIds: [trimmedAgentId] } });
+  clearLocalCheckpointCache(trimmedAgentId);
   return true;
 }
 async function cleanWebIdeWorkspaceCache(taskId, workdir, cfg2) {
@@ -4176,8 +4333,8 @@ async function cleanWebIdeWorkspaceCache(taskId, workdir, cfg2) {
     );
   }
   const dir = resolve7(trimmedWorkdir, ".apm", "webide", trimmedTaskId);
-  if (existsSync8(dir)) {
-    rmSync2(dir, { recursive: true, force: true });
+  if (existsSync9(dir)) {
+    rmSync3(dir, { recursive: true, force: true });
     console.log(`[apm] \u5DF2\u6E05\u7406 WebIDE \u7F13\u5B58 ${dir}`);
   } else {
     console.log(`[apm] WebIDE \u7F13\u5B58\u4E0D\u5B58\u5728\uFF0C\u8DF3\u8FC7 ${dir}`);
@@ -4498,8 +4655,8 @@ async function ensureWebIdePullRequests(cfg2, taskId, workdir) {
 }
 
 // src/commands/sync-webide-attachments.ts
-import { existsSync as existsSync9, readFileSync as readFileSync7, writeFileSync as writeFileSync6 } from "fs";
-import { join as join6 } from "path";
+import { existsSync as existsSync10, readFileSync as readFileSync8, writeFileSync as writeFileSync7 } from "fs";
+import { join as join7 } from "path";
 var MANIFEST_FILE2 = ".sync-manifest.json";
 async function downloadAttachment(cfg2, attachmentId) {
   const base = cfg2.baseUrl.trim().replace(/\/+$/, "");
@@ -4515,13 +4672,13 @@ async function downloadAttachment(cfg2, attachmentId) {
   return Buffer.from(await res.arrayBuffer());
 }
 function loadManifest(dir) {
-  const path3 = join6(dir, MANIFEST_FILE2);
-  if (!existsSync9(path3)) {
+  const path3 = join7(dir, MANIFEST_FILE2);
+  if (!existsSync10(path3)) {
     return { version: 1, attachments: {} };
   }
   try {
     const parsed = JSON.parse(
-      readFileSync7(path3, "utf8")
+      readFileSync8(path3, "utf8")
     );
     if (parsed?.version === 1 && parsed.attachments && typeof parsed.attachments === "object") {
       return parsed;
@@ -4531,15 +4688,15 @@ function loadManifest(dir) {
   return { version: 1, attachments: {} };
 }
 function saveManifest(dir, manifest) {
-  writeFileSync6(
-    join6(dir, MANIFEST_FILE2),
+  writeFileSync7(
+    join7(dir, MANIFEST_FILE2),
     `${JSON.stringify(manifest, null, 2)}
 `,
     "utf8"
   );
 }
 function isAttachmentUpToDate(entry, item, dest) {
-  if (!entry || !existsSync9(dest)) return false;
+  if (!entry || !existsSync10(dest)) return false;
   if (entry.name !== item.name) return false;
   const createdAt = item.createdAt ?? "";
   return entry.createdAt === createdAt;
@@ -4554,7 +4711,7 @@ async function syncAttachmentsToDirectory(cfg2, attachments, dir, logLabel) {
   const nextManifest = { version: 1, attachments: {} };
   const names = [];
   for (const item of attachments) {
-    const dest = join6(dir, item.name);
+    const dest = join7(dir, item.name);
     const entry = manifest.attachments[item.id];
     const createdAt = item.createdAt ?? "";
     names.push(item.name);
@@ -4564,7 +4721,7 @@ async function syncAttachmentsToDirectory(cfg2, attachments, dir, logLabel) {
       continue;
     }
     const buffer = await downloadAttachment(cfg2, item.id);
-    writeFileSync6(dest, buffer);
+    writeFileSync7(dest, buffer);
     nextManifest.attachments[item.id] = {
       name: item.name,
       createdAt
@@ -4585,9 +4742,9 @@ async function syncWebIdeAttachments(cfg2, taskId, workdir, attachments) {
 }
 
 // src/commands/sync-webide-design.ts
-import { createHash as createHash3 } from "crypto";
-import { existsSync as existsSync10, readdirSync as readdirSync5, readFileSync as readFileSync8, statSync as statSync5, writeFileSync as writeFileSync7 } from "fs";
-import { join as join7 } from "path";
+import { createHash as createHash4 } from "crypto";
+import { existsSync as existsSync11, readdirSync as readdirSync5, readFileSync as readFileSync9, statSync as statSync5, writeFileSync as writeFileSync8 } from "fs";
+import { join as join8 } from "path";
 
 // src/opc-shared-types.ts
 function webIdeDesignObjectKey(taskId, fileName) {
@@ -4605,15 +4762,15 @@ function webIdeDesignArtifactContentType(name) {
 // src/commands/sync-webide-design.ts
 var MANIFEST_FILE3 = ".sync-manifest.json";
 function hashBuffer(buf) {
-  return createHash3("sha256").update(buf).digest("hex");
+  return createHash4("sha256").update(buf).digest("hex");
 }
 function loadManifest2(dir) {
-  const path3 = join7(dir, MANIFEST_FILE3);
-  if (!existsSync10(path3)) {
+  const path3 = join8(dir, MANIFEST_FILE3);
+  if (!existsSync11(path3)) {
     return { version: 1, files: {} };
   }
   try {
-    const parsed = JSON.parse(readFileSync8(path3, "utf8"));
+    const parsed = JSON.parse(readFileSync9(path3, "utf8"));
     if (parsed?.version === 1 && parsed.files && typeof parsed.files === "object") {
       return parsed;
     }
@@ -4622,8 +4779,8 @@ function loadManifest2(dir) {
   return { version: 1, files: {} };
 }
 function saveManifest2(dir, manifest) {
-  writeFileSync7(
-    join7(dir, MANIFEST_FILE3),
+  writeFileSync8(
+    join8(dir, MANIFEST_FILE3),
     `${JSON.stringify(manifest, null, 2)}
 `,
     "utf8"
@@ -4651,13 +4808,13 @@ async function syncWebIdeDesign(cfg2, taskId, workdir, artifacts) {
   for (const art of artifacts) {
     const name = art.name?.trim();
     if (!name || !isWebIdeDesignArtifactName(name)) continue;
-    const localPath = join7(dir, name);
+    const localPath = join8(dir, name);
     const entry = manifest.files[name];
-    if (entry?.contentHash === art.contentHash && existsSync10(localPath)) {
+    if (entry?.contentHash === art.contentHash && existsSync11(localPath)) {
       continue;
     }
     const buf = await downloadDesignFile(cfg2, taskId, name);
-    writeFileSync7(localPath, buf);
+    writeFileSync8(localPath, buf);
     manifest.files[name] = { contentHash: hashBuffer(buf) };
     synced.push(name);
   }
@@ -4666,13 +4823,13 @@ async function syncWebIdeDesign(cfg2, taskId, workdir, artifacts) {
 }
 function listLocalDesignArtifactFiles(taskId, workdir) {
   const dir = webideDesignDir(taskId, workdir);
-  if (!existsSync10(dir)) return [];
+  if (!existsSync11(dir)) return [];
   const out = [];
   for (const name of readdirSync5(dir)) {
     if (!isWebIdeDesignArtifactName(name)) continue;
-    const absPath = join7(dir, name);
+    const absPath = join8(dir, name);
     if (!statSync5(absPath).isFile()) continue;
-    const buf = readFileSync8(absPath);
+    const buf = readFileSync9(absPath);
     if (buf.length === 0) continue;
     out.push({ name, absPath, contentHash: hashBuffer(buf) });
   }
@@ -5103,6 +5260,11 @@ async function handleWebIdeInboundMessage(cfg2, msg2, signal) {
     const savedAgentId = startLocalServices || useNewAgent ? void 0 : designAction ? loadWebIdeDesignAgentId(workdir, taskId) : loadWebIdeAgentId(workdir, taskId);
     const promptPayload = toolNames.includes("MysqlExecute") ? parseWebIdePromptPayload(msg2.content) : null;
     const sqlExecutionId = toolNames.includes("MysqlExecute") && typeof promptPayload?.executionId === "string" ? promptPayload.executionId.trim() : void 0;
+    if (toolNames.includes("MysqlExecute") && !sqlExecutionId) {
+      console.warn(
+        "[apm] \u5DE5\u5177\u540D\u5355\u542B MysqlExecute\uFF0C\u4F46 prompt \u672B\u5C3E\u6CA1\u6709 executionId\uFF0C\u672C\u8F6E\u4E0D\u4F1A\u6302\u8F7D\u8BE5\u5DE5\u5177"
+      );
+    }
     const persistAgentId = (agentId) => {
       if (startLocalServices) return;
       if (designAction) {
@@ -5212,7 +5374,7 @@ ${assumptionAnswersText}` : msg2.content,
         detail,
         tokenUsage
       );
-      if (sqlExecutionId) {
+      if (sqlExecutionId && msg2.action !== "request-bugfix") {
         try {
           await api.cli.webideFinalizeSqlExecution({
             executionId: sqlExecutionId,
@@ -5237,7 +5399,7 @@ ${assumptionAnswersText}` : msg2.content,
         "\u5DF2\u53D6\u6D88",
         tokenUsage
       );
-      if (sqlExecutionId) {
+      if (sqlExecutionId && msg2.action !== "request-bugfix") {
         try {
           await api.cli.webideFinalizeSqlExecution({
             executionId: sqlExecutionId,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai-project-manage-cli",
-  "version": "8.1.11",
+  "version": "8.1.13",
   "description": "命令行工具：后续用于调用平台后端 API 完成运维与自动化操作",
   "type": "module",
   "private": false,