ai-project-manage-cli 8.1.4 → 8.1.5

package/dist/index.js

@@ -376,6 +376,66 @@ var requestConfig = {
     projectPackageEnsureContent: defineEndpoint({
       method: "PUT",
       path: "/cli/project-packages/ensure-content"
+    }),
+    cursorStoreUpsertAgent: defineEndpoint({
+      method: "PUT",
+      path: "/cli/cursor-store/agents"
+    }),
+    cursorStoreGetAgent: defineEndpoint({
+      method: "GET",
+      path: "/cli/cursor-store/agents/get"
+    }),
+    cursorStoreListAgents: defineEndpoint({
+      method: "POST",
+      path: "/cli/cursor-store/agents/list"
+    }),
+    cursorStoreDeleteAgents: defineEndpoint({
+      method: "POST",
+      path: "/cli/cursor-store/agents/delete"
+    }),
+    cursorStoreUpsertRun: defineEndpoint({
+      method: "PUT",
+      path: "/cli/cursor-store/runs"
+    }),
+    cursorStoreGetRun: defineEndpoint({
+      method: "GET",
+      path: "/cli/cursor-store/runs/get"
+    }),
+    cursorStoreListRuns: defineEndpoint({
+      method: "POST",
+      path: "/cli/cursor-store/runs/list"
+    }),
+    cursorStoreDeleteRuns: defineEndpoint({
+      method: "POST",
+      path: "/cli/cursor-store/runs/delete"
+    }),
+    cursorStoreAppendRunEvents: defineEndpoint({
+      method: "POST",
+      path: "/cli/cursor-store/run-events/append"
+    }),
+    cursorStoreListRunEvents: defineEndpoint({
+      method: "POST",
+      path: "/cli/cursor-store/run-events/list"
+    }),
+    cursorStoreDeleteRunEvents: defineEndpoint({
+      method: "POST",
+      path: "/cli/cursor-store/run-events/delete"
+    }),
+    cursorStorePutCheckpoint: defineEndpoint({
+      method: "PUT",
+      path: "/cli/cursor-store/checkpoints"
+    }),
+    cursorStoreGetCheckpoint: defineEndpoint({
+      method: "GET",
+      path: "/cli/cursor-store/checkpoints/get"
+    }),
+    cursorStoreListCheckpoints: defineEndpoint({
+      method: "POST",
+      path: "/cli/cursor-store/checkpoints/list"
+    }),
+    cursorStoreDeleteCheckpoints: defineEndpoint({
+      method: "POST",
+      path: "/cli/cursor-store/checkpoints/delete"
     })
   }
 };

package/dist/worker-script.js

@@ -124,6 +124,66 @@ var requestConfig = {
     projectPackageEnsureContent: defineEndpoint({
       method: "PUT",
       path: "/cli/project-packages/ensure-content"
+    }),
+    cursorStoreUpsertAgent: defineEndpoint({
+      method: "PUT",
+      path: "/cli/cursor-store/agents"
+    }),
+    cursorStoreGetAgent: defineEndpoint({
+      method: "GET",
+      path: "/cli/cursor-store/agents/get"
+    }),
+    cursorStoreListAgents: defineEndpoint({
+      method: "POST",
+      path: "/cli/cursor-store/agents/list"
+    }),
+    cursorStoreDeleteAgents: defineEndpoint({
+      method: "POST",
+      path: "/cli/cursor-store/agents/delete"
+    }),
+    cursorStoreUpsertRun: defineEndpoint({
+      method: "PUT",
+      path: "/cli/cursor-store/runs"
+    }),
+    cursorStoreGetRun: defineEndpoint({
+      method: "GET",
+      path: "/cli/cursor-store/runs/get"
+    }),
+    cursorStoreListRuns: defineEndpoint({
+      method: "POST",
+      path: "/cli/cursor-store/runs/list"
+    }),
+    cursorStoreDeleteRuns: defineEndpoint({
+      method: "POST",
+      path: "/cli/cursor-store/runs/delete"
+    }),
+    cursorStoreAppendRunEvents: defineEndpoint({
+      method: "POST",
+      path: "/cli/cursor-store/run-events/append"
+    }),
+    cursorStoreListRunEvents: defineEndpoint({
+      method: "POST",
+      path: "/cli/cursor-store/run-events/list"
+    }),
+    cursorStoreDeleteRunEvents: defineEndpoint({
+      method: "POST",
+      path: "/cli/cursor-store/run-events/delete"
+    }),
+    cursorStorePutCheckpoint: defineEndpoint({
+      method: "PUT",
+      path: "/cli/cursor-store/checkpoints"
+    }),
+    cursorStoreGetCheckpoint: defineEndpoint({
+      method: "GET",
+      path: "/cli/cursor-store/checkpoints/get"
+    }),
+    cursorStoreListCheckpoints: defineEndpoint({
+      method: "POST",
+      path: "/cli/cursor-store/checkpoints/list"
+    }),
+    cursorStoreDeleteCheckpoints: defineEndpoint({
+      method: "POST",
+      path: "/cli/cursor-store/checkpoints/delete"
     })
   }
 };
@@ -2385,6 +2445,330 @@ function createPtySessionMcpServers(cfg2) {
   };
 }
 
+// src/commands/connect/remote-local-agent-store.ts
+function asCheckpointRef(value) {
+  if (value === void 0) return void 0;
+  if (value === null) return null;
+  if (!value || typeof value !== "object") return null;
+  const row = value;
+  if (typeof row.rootBlobId !== "string" || !row.rootBlobId.trim()) {
+    return null;
+  }
+  return {
+    schemaVersion: 1,
+    rootBlobId: row.rootBlobId
+  };
+}
+function toApiCheckpointRef(ref) {
+  if (ref === void 0) return void 0;
+  if (ref === null) return null;
+  return {
+    schemaVersion: ref.schemaVersion,
+    rootBlobId: ref.rootBlobId
+  };
+}
+function fromApiAgent(row) {
+  return {
+    agentId: row.agentId,
+    cwd: row.cwd,
+    status: row.status,
+    activeRunId: row.activeRunId,
+    name: row.name,
+    createdAt: row.createdAt,
+    updatedAt: row.updatedAt,
+    latestCheckpoint: asCheckpointRef(row.latestCheckpoint) ?? null,
+    sdkMetadata: row.sdkMetadata ?? void 0
+  };
+}
+function fromApiRun(row) {
+  return {
+    runId: row.runId,
+    requestId: row.requestId,
+    agentId: row.agentId,
+    turnNumber: row.turnNumber,
+    status: row.status,
+    model: row.model ?? null,
+    result: row.result,
+    error: row.error,
+    usageRef: row.usageRef,
+    usage: row.usage ?? null,
+    createdAt: row.createdAt,
+    updatedAt: row.updatedAt,
+    startedAt: row.startedAt,
+    endedAt: row.endedAt,
+    startCheckpointRef: asCheckpointRef(row.startCheckpointRef) ?? null,
+    latestCheckpointRef: asCheckpointRef(row.latestCheckpointRef) ?? null
+  };
+}
+function fromApiEvent(row) {
+  return {
+    runId: row.runId,
+    seq: row.seq,
+    offset: row.offset,
+    eventType: row.eventType,
+    payload: row.payload,
+    payloadRef: row.payloadRef,
+    idempotencyKey: row.idempotencyKey,
+    createdAt: row.createdAt
+  };
+}
+function bytesToBase64(data) {
+  return Buffer.from(data).toString("base64");
+}
+function base64ToBytes(dataBase64) {
+  return new Uint8Array(Buffer.from(dataBase64, "base64"));
+}
+function createRemoteLocalAgentStore(cfg2) {
+  const api = createApmApiClient(cfg2);
+  async function upsertAgent(agent) {
+    const row = await api.cli.cursorStoreUpsertAgent({
+      agentId: agent.agentId,
+      cwd: agent.cwd,
+      status: agent.status,
+      activeRunId: agent.activeRunId ?? null,
+      name: agent.name ?? null,
+      latestCheckpoint: toApiCheckpointRef(agent.latestCheckpoint) ?? null,
+      sdkMetadata: agent.sdkMetadata ?? null,
+      createdAt: agent.createdAt,
+      updatedAt: agent.updatedAt
+    });
+    return fromApiAgent(row);
+  }
+  async function upsertRun(run) {
+    const row = await api.cli.cursorStoreUpsertRun({
+      runId: run.runId,
+      agentId: run.agentId,
+      requestId: run.requestId ?? null,
+      turnNumber: run.turnNumber,
+      status: run.status,
+      model: run.model ?? null,
+      result: run.result ?? null,
+      error: run.error ?? null,
+      usageRef: run.usageRef ?? null,
+      usage: run.usage ?? null,
+      startCheckpointRef: toApiCheckpointRef(run.startCheckpointRef) ?? null,
+      latestCheckpointRef: toApiCheckpointRef(run.latestCheckpointRef) ?? null,
+      createdAt: run.createdAt,
+      updatedAt: run.updatedAt,
+      startedAt: run.startedAt ?? null,
+      endedAt: run.endedAt ?? null
+    });
+    return fromApiRun(row);
+  }
+  async function putCheckpoint(input) {
+    await api.cli.cursorStorePutCheckpoint({
+      agentId: input.agentId,
+      blobId: input.blobId,
+      dataBase64: bytesToBase64(input.data),
+      byteSize: input.data.byteLength,
+      createdAt: Date.now()
+    });
+  }
+  return {
+    agents: {
+      async get(input) {
+        const row = await api.cli.cursorStoreGetAgent({
+          agentId: input.agentId
+        });
+        return row ? fromApiAgent(row) : null;
+      },
+      async create(input) {
+        return upsertAgent(input.agent);
+      },
+      async update(input) {
+        return upsertAgent(input.agent);
+      },
+      async delete(input) {
+        const agentIds = input.filter.agentIds?.map((id) => id.trim()).filter(Boolean);
+        const cwd = input.filter.cwd?.trim();
+        if (agentIds && agentIds.length > 0) {
+          await api.cli.cursorStoreDeleteAgents({ agentIds, cwd });
+          return;
+        }
+        if (cwd) {
+          await api.cli.cursorStoreDeleteAgents({ cwd });
+          return;
+        }
+        let cursor;
+        for (; ; ) {
+          const page = await api.cli.cursorStoreListAgents({
+            cursor,
+            limit: 200
+          });
+          if (page.items.length === 0) break;
+          await api.cli.cursorStoreDeleteAgents({
+            agentIds: page.items.map((item) => item.agentId)
+          });
+          if (!page.nextCursor) break;
+          cursor = page.nextCursor;
+        }
+      },
+      async list(input) {
+        const page = await api.cli.cursorStoreListAgents({
+          cursor: input?.filter?.cursor,
+          limit: input?.filter?.limit,
+          cwd: input?.filter?.cwd
+        });
+        const result = {
+          items: page.items.map(fromApiAgent),
+          ...page.nextCursor ? { nextCursor: page.nextCursor } : {}
+        };
+        return result;
+      }
+    },
+    runs: {
+      async get(input) {
+        const row = await api.cli.cursorStoreGetRun({
+          agentId: input.agentId,
+          runId: input.runId
+        });
+        return row ? fromApiRun(row) : null;
+      },
+      async create(input) {
+        return upsertRun(input.run);
+      },
+      async update(input) {
+        return upsertRun(input.run);
+      },
+      async delete(input) {
+        const agentIds = input.filter.agentIds?.map((id) => id.trim()).filter(Boolean);
+        const runIds = input.filter.runIds?.map((id) => id.trim()).filter(Boolean);
+        if (agentIds && agentIds.length > 0 || runIds && runIds.length > 0) {
+          await api.cli.cursorStoreDeleteRuns({ agentIds, runIds });
+          return;
+        }
+        let cursor;
+        for (; ; ) {
+          const page = await api.cli.cursorStoreListRuns({
+            cursor,
+            limit: 200
+          });
+          if (page.items.length === 0) break;
+          await api.cli.cursorStoreDeleteRuns({
+            runIds: page.items.map((item) => item.runId)
+          });
+          if (!page.nextCursor) break;
+          cursor = page.nextCursor;
+        }
+      },
+      async list(input) {
+        const page = await api.cli.cursorStoreListRuns({
+          agentIds: input?.filter?.agentIds ? [...input.filter.agentIds] : void 0,
+          runIds: input?.filter?.runIds ? [...input.filter.runIds] : void 0,
+          cursor: input?.filter?.cursor,
+          limit: input?.filter?.limit
+        });
+        const result = {
+          items: page.items.map(fromApiRun),
+          ...page.nextCursor ? { nextCursor: page.nextCursor } : {}
+        };
+        return result;
+      }
+    },
+    runEvents: {
+      async append(input) {
+        const { items } = await api.cli.cursorStoreAppendRunEvents({
+          events: [
+            {
+              runId: input.runId,
+              eventType: input.eventType,
+              payload: input.payload,
+              payloadRef: input.payloadRef ?? null,
+              idempotencyKey: input.idempotencyKey ?? null
+            }
+          ]
+        });
+        const row = items[0];
+        if (!row) {
+          throw new Error("cursor-store append run event \u672A\u8FD4\u56DE\u7ED3\u679C");
+        }
+        return fromApiEvent(row);
+      },
+      async list(input) {
+        const page = await api.cli.cursorStoreListRunEvents({
+          runId: input.runId,
+          afterOffset: input.afterOffset ?? null,
+          limit: input.limit
+        });
+        return {
+          items: page.items.map(fromApiEvent),
+          ...page.nextOffset ? { nextOffset: page.nextOffset } : {}
+        };
+      },
+      async delete(input) {
+        const runIds = input.filter.runIds?.map((id) => id.trim()).filter(Boolean);
+        if (runIds && runIds.length > 0) {
+          await api.cli.cursorStoreDeleteRunEvents({ runIds });
+          return;
+        }
+        let cursor;
+        for (; ; ) {
+          const page = await api.cli.cursorStoreListRuns({
+            cursor,
+            limit: 200
+          });
+          if (page.items.length === 0) break;
+          await api.cli.cursorStoreDeleteRunEvents({
+            runIds: page.items.map((item) => item.runId)
+          });
+          if (!page.nextCursor) break;
+          cursor = page.nextCursor;
+        }
+      }
+    },
+    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);
+      },
+      async create(input) {
+        await putCheckpoint(input);
+      },
+      async update(input) {
+        await putCheckpoint(input);
+      },
+      async delete(input) {
+        const agentIds = input.filter.agentIds?.map((id) => id.trim()).filter(Boolean);
+        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 });
+          return;
+        }
+        let cursor;
+        for (; ; ) {
+          const page = await api.cli.cursorStoreListCheckpoints({
+            cursor,
+            limit: 200
+          });
+          if (page.items.length === 0) break;
+          await api.cli.cursorStoreDeleteCheckpoints({
+            agentIds: [...new Set(page.items.map((item) => item.agentId))],
+            blobIds: page.items.map((item) => item.blobId)
+          });
+          if (!page.nextCursor) break;
+          cursor = page.nextCursor;
+        }
+      },
+      async list(input) {
+        const page = await api.cli.cursorStoreListCheckpoints({
+          agentIds: input?.filter?.agentIds ? [...input.filter.agentIds] : void 0,
+          blobIds: input?.filter?.blobIds ? [...input.filter.blobIds] : void 0,
+          cursor: input?.filter?.cursor,
+          limit: input?.filter?.limit
+        });
+        return {
+          items: page.items.map((item) => item.blobId),
+          ...page.nextCursor ? { nextCursor: page.nextCursor } : {}
+        };
+      }
+    }
+  };
+}
+
 // src/commands/connect/cursor-agent.ts
 var noopRemoteLogSync = {
   schedule(_session) {
@@ -2406,11 +2790,13 @@ function formatCursorRunFailure(runId, options) {
   return `Cursor run \u5931\u8D25: ${runId} \u2014 ${details.join("\uFF1B")}`;
 }
 async function obtainAgent(ctx) {
+  const store = createRemoteLocalAgentStore(ctx.cfg);
   const agentOptions = {
     apiKey: ctx.apiKey,
     model: { id: ctx.model || "default" },
     local: {
       cwd: ctx.cwd,
+      store,
       ...ctx.customTools ? { customTools: ctx.customTools } : {},
       ...ctx.enableSandbox ? {
         sandboxOptions: { enabled: true },
@@ -2481,6 +2867,7 @@ async function runCursorAgent(cfg2, ctx, options) {
     `[apm] Cursor Agent \u5F00\u59CB messageId=${ctx.messageId} cwd=${workdir} sandbox=${enableSandbox}`
   );
   const { agent, resumed } = await obtainAgent({
+    cfg: cfg2,
     apiKey,
     model: ctx.model,
     cwd: workdir,
@@ -3681,48 +4068,34 @@ function clearWebIdeDesignAgentId(workdir, taskId) {
 // src/commands/clean-webide-cache.ts
 import { existsSync as existsSync8, rmSync as rmSync2 } from "node:fs";
 import { resolve as resolve7 } from "node:path";
-import { getDefaultSdkStateRoot } from "@cursor/sdk";
-async function purgeCursorAgentStoreForAgent(workdir, agentId) {
+async function purgeCursorAgentStoreForAgent(cfg2, agentId) {
   const trimmedAgentId = agentId.trim();
-  const trimmedWorkdir = workdir.trim();
-  if (!trimmedAgentId || !trimmedWorkdir) return false;
-  const stateRoot = getDefaultSdkStateRoot(trimmedWorkdir);
-  if (!existsSync8(stateRoot)) return false;
-  const { SqliteLocalAgentStore } = await import(
-    /* @vite-ignore */
-    "@cursor/sdk/sqlite"
-  );
-  const store = await SqliteLocalAgentStore.open({
-    workspaceRef: trimmedWorkdir
-  });
-  try {
-    const runIds = [];
-    let cursor;
-    do {
-      const page = await store.runs.list({
-        filter: {
-          agentIds: [trimmedAgentId],
-          ...cursor ? { cursor } : {},
-          limit: 200
-        }
-      });
-      for (const run of page.items) {
-        runIds.push(run.runId);
+  if (!trimmedAgentId) return false;
+  const store = createRemoteLocalAgentStore(cfg2);
+  const runIds = [];
+  let cursor;
+  do {
+    const page = await store.runs.list({
+      filter: {
+        agentIds: [trimmedAgentId],
+        ...cursor ? { cursor } : {},
+        limit: 200
       }
-      cursor = page.nextCursor;
-    } while (cursor);
-    if (runIds.length > 0) {
-      await store.runEvents.delete({ filter: { runIds } });
+    });
+    for (const run of page.items) {
+      runIds.push(run.runId);
     }
-    await store.runs.delete({ filter: { agentIds: [trimmedAgentId] } });
-    await store.checkpoints.delete({ filter: { agentIds: [trimmedAgentId] } });
-    await store.agents.delete({ filter: { agentIds: [trimmedAgentId] } });
-  } finally {
-    await store.dispose();
-  }
+    cursor = page.nextCursor;
+  } while (cursor);
+  if (runIds.length > 0) {
+    await store.runEvents.delete({ filter: { runIds } });
+  }
+  await store.runs.delete({ filter: { agentIds: [trimmedAgentId] } });
+  await store.checkpoints.delete({ filter: { agentIds: [trimmedAgentId] } });
+  await store.agents.delete({ filter: { agentIds: [trimmedAgentId] } });
   return true;
 }
-async function cleanWebIdeWorkspaceCache(taskId, workdir) {
+async function cleanWebIdeWorkspaceCache(taskId, workdir, cfg2) {
   const trimmedTaskId = taskId.trim();
   const trimmedWorkdir = workdir.trim();
   if (!trimmedTaskId || !trimmedWorkdir) {
@@ -3731,10 +4104,7 @@ async function cleanWebIdeWorkspaceCache(taskId, workdir) {
   const agentId = loadWebIdeAgentId(trimmedWorkdir, trimmedTaskId);
   if (agentId) {
     try {
-      const purged = await purgeCursorAgentStoreForAgent(
-        trimmedWorkdir,
-        agentId
-      );
+      const purged = await purgeCursorAgentStoreForAgent(cfg2, agentId);
       if (purged) {
         console.log(
           `[apm] \u5DF2\u6E05\u7406 Cursor agent store agentId=${agentId} taskId=${trimmedTaskId}`
@@ -4925,7 +5295,7 @@ ${assumptionAnswersText}` : msg2.content,
     );
     if (msg2.action === "request-accept") {
       try {
-        await cleanWebIdeWorkspaceCache(taskId, workdir);
+        await cleanWebIdeWorkspaceCache(taskId, workdir, cfg2);
       } catch (err) {
         console.warn(
           "[apm] \u5408\u5E76 PR \u540E\u6E05\u7406 WebIDE agent \u7F13\u5B58\u5931\u8D25:",
@@ -4948,14 +5318,9 @@ ${assumptionAnswersText}` : msg2.content,
       );
     }
     const completeAction = completeActionForInbound(msg2.action);
-    if (completeAction && !pausedForAssumptions) {
+    if (completeAction === "complete-assessment" && !pausedForAssumptions) {
       try {
-        await webIdeRunAction(
-          cfg2,
-          taskId,
-          completeAction,
-          completeAction === "complete-assessment" ? { force: true } : void 0
-        );
+        await webIdeRunAction(cfg2, taskId, completeAction, { force: true });
       } catch (completeErr) {
         console.warn(
           `[apm] \u5931\u8D25\u540E\u56DE\u5199 complete \u8DF3\u8FC7 action=${completeAction}:`,

package/package.json

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