ai-project-manage-cli 8.0.7 → 8.0.9

package/dist/webide-message-worker.js

@@ -58,6 +58,14 @@ var requestConfig = {
       method: "PUT",
       path: "/cli/webide/test-cases"
     }),
+    webideUpsertSqlExecution: defineEndpoint({
+      method: "PUT",
+      path: "/cli/webide/sql-executions"
+    }),
+    webideFinalizeSqlExecution: defineEndpoint({
+      method: "PUT",
+      path: "/cli/webide/sql-executions/finalize"
+    }),
     projectBaseBranch: defineEndpoint(
       {
         method: "GET",
@@ -91,6 +99,18 @@ var requestConfig = {
     getApmLogStorage: defineEndpoint({
       method: "GET",
       path: "/cli/apm-log-storage"
+    }),
+    projectPackageUpdateStatus: defineEndpoint({
+      method: "PUT",
+      path: "/cli/project-packages/status"
+    }),
+    projectPackageAppendContent: defineEndpoint({
+      method: "PUT",
+      path: "/cli/project-packages/content"
+    }),
+    projectPackageEnsureContent: defineEndpoint({
+      method: "PUT",
+      path: "/cli/project-packages/ensure-content"
     })
   }
 };
@@ -934,6 +954,55 @@ async function runTaskBranch(taskId, options = {}) {
     repos: repoRoots
   };
 }
+async function checkoutBaselineBranches(baselineBranch, options = {}) {
+  const baseline = baselineBranch.trim().replace(/^origin\//, "");
+  if (!baseline) {
+    throw new Error("[apm] \u57FA\u7EBF\u5206\u652F\u4E0D\u80FD\u4E3A\u7A7A");
+  }
+  const cwd = options.cwd ?? process.cwd();
+  const workdirPath = resolveWorkdirPath(cwd);
+  const manifest = loadWorkspaceReposCache(workdirPath);
+  const repoRoots = resolveWorkspaceRepoAbsolutePaths(manifest);
+  for (const gitRoot of repoRoots) {
+    const label = formatRepoLabel(workdirPath, gitRoot);
+    console.log(`[apm] \u5207\u6362\u57FA\u7EBF\u5206\u652F ${baseline} @ ${label}`);
+    await checkoutBaselineBranch(baseline, { ...options, cwd: gitRoot });
+  }
+  return {
+    baseline,
+    kind: manifest.kind,
+    repos: repoRoots
+  };
+}
+async function checkoutBaselineBranch(baselineBranch, options = {}) {
+  const baseline = baselineBranch.trim().replace(/^origin\//, "");
+  if (!baseline) {
+    throw new Error("[apm] \u57FA\u7EBF\u5206\u652F\u4E0D\u80FD\u4E3A\u7A7A");
+  }
+  const cwd = options.cwd ?? process.cwd();
+  const gitRoot = await resolveGitRepoRoot(cwd);
+  await ensureGitRepo(gitRoot);
+  if (await isWorkingTreeDirty(gitRoot)) {
+    throw new Error(
+      `[apm] \u5DE5\u4F5C\u533A\u6709\u672A\u63D0\u4EA4\u53D8\u66F4\uFF0C\u65E0\u6CD5\u5207\u6362\u5230\u57FA\u7EBF\u5206\u652F ${baseline}`
+    );
+  }
+  await ensureRemoteBaselineBranch(gitRoot, baseline);
+  const current = await getCurrentBranch(gitRoot);
+  if (current === baseline) {
+    await execGit(gitRoot, ["reset", "--hard", `origin/${baseline}`]);
+    console.log(`[apm] \u5DF2\u5728\u57FA\u7EBF ${baseline}\uFF0C\u5DF2\u5BF9\u9F50 origin/${baseline}`);
+    return baseline;
+  }
+  await execGit(gitRoot, [
+    "checkout",
+    "-B",
+    baseline,
+    `origin/${baseline}`
+  ]);
+  console.log(`[apm] \u5DF2\u5207\u6362\u5230\u57FA\u7EBF\u5206\u652F ${baseline}`);
+  return baseline;
+}
 
 // src/commands/connect/cursor-agent.ts
 import {
@@ -1515,6 +1584,325 @@ function createUpsertWebIdeTestCasesTool(options) {
   };
 }
 
+// src/commands/connect/tools/mysql-tools.ts
+import { existsSync as existsSync3, readFileSync as readFileSync3, statSync as statSync3 } from "node:fs";
+import { isAbsolute, relative as relative2, resolve as resolve4 } from "node:path";
+import mysql from "mysql2/promise";
+var MAX_RESULT_ROWS = 100;
+var EXEC_TIMEOUT_MS = 6e4;
+var MAX_SQL_FILE_BYTES = 2 * 1024 * 1024;
+function asString3(value) {
+  return typeof value === "string" ? value.trim() : "";
+}
+function asNumber(value) {
+  if (typeof value === "number" && Number.isFinite(value)) return value;
+  if (typeof value === "string" && value.trim()) {
+    const parsed = Number(value);
+    if (Number.isFinite(parsed)) return parsed;
+  }
+  return void 0;
+}
+function isResultSetHeader(value) {
+  return typeof value === "object" && value !== null && "affectedRows" in value && !Array.isArray(value);
+}
+function formatOkPacket(packet) {
+  return {
+    kind: "update",
+    affectedRows: packet.affectedRows ?? 0,
+    insertId: packet.insertId ?? 0,
+    changedRows: packet.changedRows,
+    warnings: packet.warningStatus
+  };
+}
+function formatSelectRows(rows) {
+  const truncated = rows.slice(0, MAX_RESULT_ROWS);
+  return {
+    kind: "select",
+    rowCount: rows.length,
+    truncated: rows.length > MAX_RESULT_ROWS,
+    rows: truncated
+  };
+}
+function formatStatementResult(result) {
+  if (Array.isArray(result)) {
+    return formatSelectRows(result);
+  }
+  if (isResultSetHeader(result)) {
+    return formatOkPacket(result);
+  }
+  return { kind: "unknown", value: result };
+}
+function normalizeMultiStatementResults(raw) {
+  if (!Array.isArray(raw)) {
+    return [formatStatementResult(raw)];
+  }
+  if (raw.length === 0) {
+    return [];
+  }
+  const first = raw[0];
+  if (Array.isArray(first)) {
+    return raw.map((item) => {
+      if (Array.isArray(item)) {
+        return formatStatementResult(item[0]);
+      }
+      return formatStatementResult(item);
+    });
+  }
+  if (isResultSetHeader(first)) {
+    return raw.map((item) => formatStatementResult(item));
+  }
+  return [formatStatementResult(raw)];
+}
+function resolveSqlArtifactPath(workdir, absolutePath) {
+  if (!isAbsolute(absolutePath)) {
+    return { ok: false, error: "path \u5FC5\u987B\u662F\u7EDD\u5BF9\u8DEF\u5F84" };
+  }
+  const workdirAbs = resolve4(toFsPath(workdir));
+  const targetAbs = resolve4(toFsPath(absolutePath));
+  const rel = relative2(workdirAbs, targetAbs);
+  if (!rel || rel.startsWith("..") || isAbsolute(rel)) {
+    return { ok: false, error: "path \u5FC5\u987B\u4F4D\u4E8E\u5F53\u524D\u5DE5\u4F5C\u533A\u5185" };
+  }
+  const fsPath = toFsPath(targetAbs);
+  if (!existsSync3(fsPath)) {
+    return { ok: false, error: `\u6587\u4EF6\u4E0D\u5B58\u5728: ${absolutePath}` };
+  }
+  let st;
+  try {
+    st = statSync3(fsPath);
+  } catch {
+    return { ok: false, error: `\u65E0\u6CD5\u8BFB\u53D6\u6587\u4EF6: ${absolutePath}` };
+  }
+  if (!st.isFile()) {
+    return { ok: false, error: "path \u5FC5\u987B\u6307\u5411\u666E\u901A\u6587\u4EF6" };
+  }
+  if (st.size > MAX_SQL_FILE_BYTES) {
+    return {
+      ok: false,
+      error: `SQL \u6587\u4EF6\u8FC7\u5927\uFF08>${MAX_SQL_FILE_BYTES} bytes\uFF09`
+    };
+  }
+  const displayPath = normalizeWorkdirPath(rel) || normalizeWorkdirPath(absolutePath);
+  return { ok: true, absPath: targetAbs, displayPath };
+}
+function readSqlFile(absPath) {
+  return readFileSync3(toFsPath(absPath), "utf8");
+}
+function createMysqlExecuteTool(options) {
+  const { taskId, executionId, workdir, upsertSqlExecution } = options;
+  return {
+    MysqlExecute: {
+      description: "Execute SQL from a workspace artifact file against MySQL. Pass the absolute filesystem path of the SQL file (not the SQL text). The CLI reads the file itself to avoid escaping issues with multi-statement scripts.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          host: { type: "string", description: "MySQL host" },
+          port: { type: "number", description: "MySQL port, default 3306" },
+          user: { type: "string", description: "MySQL username" },
+          password: { type: "string", description: "MySQL password" },
+          database: { type: "string", description: "Database name" },
+          path: {
+            type: "string",
+            description: "Absolute filesystem path to the SQL artifact file under the current workspace (CLI reads the file; do not pass SQL text)"
+          }
+        },
+        required: ["host", "user", "password", "database", "path"]
+      },
+      execute: async (args) => {
+        const host = asString3(args.host);
+        const user = asString3(args.user);
+        const password = asString3(args.password);
+        const database = asString3(args.database);
+        const pathArg = asString3(args.path);
+        const port = asNumber(args.port) ?? 3306;
+        if (!host || !user || !database || !pathArg) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: "host / user / database / path \u5747\u4E0D\u80FD\u4E3A\u7A7A"
+              }
+            ],
+            isError: true
+          };
+        }
+        const resolved = resolveSqlArtifactPath(workdir, pathArg);
+        if (!resolved.ok) {
+          try {
+            await upsertSqlExecution({
+              executionId,
+              taskId,
+              status: "FAILED",
+              artifactPath: pathArg,
+              error: resolved.error,
+              host,
+              port,
+              database,
+              dbUser: user
+            });
+          } catch {
+          }
+          return {
+            content: [{ type: "text", text: resolved.error }],
+            isError: true
+          };
+        }
+        let sql;
+        try {
+          sql = readSqlFile(resolved.absPath).trim();
+        } catch (err) {
+          const detail = err instanceof Error ? err.message : String(err);
+          try {
+            await upsertSqlExecution({
+              executionId,
+              taskId,
+              status: "FAILED",
+              artifactPath: resolved.displayPath,
+              error: `\u8BFB\u53D6 SQL \u6587\u4EF6\u5931\u8D25: ${detail}`,
+              host,
+              port,
+              database,
+              dbUser: user
+            });
+          } catch {
+          }
+          return {
+            content: [
+              {
+                type: "text",
+                text: `\u8BFB\u53D6 SQL \u6587\u4EF6\u5931\u8D25: ${detail}`
+              }
+            ],
+            isError: true
+          };
+        }
+        if (!sql) {
+          try {
+            await upsertSqlExecution({
+              executionId,
+              taskId,
+              status: "FAILED",
+              artifactPath: resolved.displayPath,
+              sql: "",
+              error: "SQL \u6587\u4EF6\u4E3A\u7A7A",
+              host,
+              port,
+              database,
+              dbUser: user
+            });
+          } catch {
+          }
+          return {
+            content: [{ type: "text", text: "SQL \u6587\u4EF6\u4E3A\u7A7A" }],
+            isError: true
+          };
+        }
+        let connection;
+        try {
+          connection = await mysql.createConnection({
+            host,
+            port,
+            user,
+            password,
+            database,
+            multipleStatements: true,
+            connectTimeout: 15e3
+          });
+          const [rawResults] = await connection.query({
+            sql,
+            timeout: EXEC_TIMEOUT_MS
+          });
+          const statements = normalizeMultiStatementResults(rawResults);
+          const resultPayload = {
+            ok: true,
+            path: resolved.displayPath,
+            statements,
+            host,
+            port,
+            database,
+            dbUser: user
+          };
+          await upsertSqlExecution({
+            executionId,
+            taskId,
+            status: "SUCCESS",
+            artifactPath: resolved.displayPath,
+            sql,
+            result: resultPayload,
+            host,
+            port,
+            database,
+            dbUser: user
+          });
+          return JSON.stringify(resultPayload, null, 2);
+        } catch (err) {
+          const detail = err instanceof Error ? err.message : String(err);
+          try {
+            await upsertSqlExecution({
+              executionId,
+              taskId,
+              status: "FAILED",
+              artifactPath: resolved.displayPath,
+              sql,
+              error: detail,
+              host: host || void 0,
+              port,
+              database: database || void 0,
+              dbUser: user || void 0
+            });
+          } catch {
+          }
+          return {
+            content: [{ type: "text", text: `MySQL \u6267\u884C\u5931\u8D25: ${detail}` }],
+            isError: true
+          };
+        } finally {
+          await connection?.end().catch(() => void 0);
+        }
+      }
+    }
+  };
+}
+
+// src/commands/connect/tools/package-status-tool.ts
+function createSetPackageFailedTool(options) {
+  const { packageId, setFailed } = options;
+  return {
+    SetPackageFailed: {
+      description: "\u6253\u5305\u5931\u8D25\u65F6\u8C03\u7528\uFF1A\u5C06\u5F53\u524D\u6253\u5305\u8BB0\u5F55\u6807\u4E3A FAILED\uFF0C\u5E76\u5199\u5165\u5931\u8D25\u539F\u56E0\u3002\u6784\u5EFA\u5931\u8D25\u3001\u7F3A\u4EA7\u7269\u3001\u6587\u6863\u7F3A\u5931\u7B49\u5747\u5E94\u8C03\u7528\uFF1B\u6210\u529F\u65F6\u4E0D\u8981\u8C03\u7528\u3002",
+      inputSchema: {
+        type: "object",
+        properties: {
+          error: {
+            type: "string",
+            description: "\u5931\u8D25\u539F\u56E0\u6458\u8981\uFF08\u4F1A\u5199\u5165\u6253\u5305\u8BB0\u5F55\uFF0C\u4F9B\u5217\u8868/\u65E5\u5FD7\u5C55\u793A\uFF09"
+          }
+        },
+        required: ["error"]
+      },
+      execute: async (args) => {
+        const error = typeof args.error === "string" ? args.error.trim() : "";
+        if (!error) {
+          return {
+            content: [{ type: "text", text: "error \u4E0D\u80FD\u4E3A\u7A7A" }],
+            isError: true
+          };
+        }
+        try {
+          await setFailed(error);
+          return `\u5DF2\u5C06\u6253\u5305\u8BB0\u5F55 ${packageId} \u6807\u4E3A FAILED`;
+        } catch (err) {
+          const detail = err instanceof Error ? err.message : String(err);
+          return {
+            content: [{ type: "text", text: `\u5199\u5165\u5931\u8D25\u72B6\u6001\u5931\u8D25: ${detail}` }],
+            isError: true
+          };
+        }
+      }
+    }
+  };
+}
+
 // src/commands/connect/tools/index.ts
 var PLAN_MODE_ASK_QUESTION_HINT = `[SDK \u73AF\u5883\u8BF4\u660E]
 AskQuestion \u5DF2\u901A\u8FC7 MCP \u670D\u52A1\u5668 custom-user-tools \u6CE8\u518C\uFF0C\u5DE5\u5177\u540D\u4E3A AskQuestion\u3002
@@ -1553,6 +1941,35 @@ function createCursorCustomTools(cfg, options) {
         })
       );
     }
+    if (options.enableMysqlTools && options.sqlExecutionId && options.workdir) {
+      Object.assign(
+        tools,
+        createMysqlExecuteTool({
+          taskId,
+          executionId: options.sqlExecutionId,
+          workdir: options.workdir,
+          upsertSqlExecution: (args) => cli.webideUpsertSqlExecution(args)
+        })
+      );
+    }
+  }
+  if (options.enablePackageStatusTools && options.packageId) {
+    const packageId = options.packageId;
+    const { cli } = createApmApiClient(cfg);
+    Object.assign(
+      tools,
+      createSetPackageFailedTool({
+        packageId,
+        setFailed: async (error) => {
+          await cli.projectPackageUpdateStatus({
+            id: packageId,
+            status: "FAILED",
+            error
+          });
+          await options.onPackageFailed?.(error);
+        }
+      })
+    );
   }
   return tools;
 }
@@ -1671,8 +2088,13 @@ async function runCursorAgent(cfg, ctx, options) {
     enableAskQuestion: options.enableAskQuestion,
     askQuestionExecute: options.askQuestionExecute,
     enableWebIdePlanTools: options.enableWebIdePlanTools,
+    enableMysqlTools: options.enableMysqlTools,
+    sqlExecutionId: options.sqlExecutionId,
     taskId: options.taskId,
-    workdir
+    workdir,
+    enablePackageStatusTools: options.enablePackageStatusTools,
+    packageId: options.packageId,
+    onPackageFailed: options.onPackageFailed
   });
   const enableSandbox = Boolean(options.enableSandbox);
   const mcpServers = options.enablePtySessionMcp ? createPtySessionMcpServers(cfg) : void 0;
@@ -1805,17 +2227,17 @@ async function runCursorAgent(cfg, ctx, options) {
 }
 
 // src/commands/connect/webide-agent-registry.ts
-import { existsSync as existsSync3, mkdirSync as mkdirSync4, readFileSync as readFileSync3, writeFileSync as writeFileSync3 } from "node:fs";
-import { dirname as dirname3, resolve as resolve4 } from "node:path";
+import { existsSync as existsSync4, mkdirSync as mkdirSync4, readFileSync as readFileSync4, writeFileSync as writeFileSync3 } from "node:fs";
+import { dirname as dirname3, resolve as resolve5 } from "node:path";
 function registryPath(workdir, taskId) {
-  return resolve4(workdir, ".apm", "webide", taskId, "cursor-agent.json");
+  return resolve5(workdir, ".apm", "webide", taskId, "cursor-agent.json");
 }
 function readRegistry(path) {
-  if (!existsSync3(path)) {
+  if (!existsSync4(path)) {
     return {};
   }
   try {
-    const parsed = JSON.parse(readFileSync3(path, "utf8"));
+    const parsed = JSON.parse(readFileSync4(path, "utf8"));
     if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
       const raw = parsed;
       const state = {};
@@ -1886,20 +2308,20 @@ function saveWebIdeAgentId(workdir, taskId, agentId) {
 }
 function clearWebIdeAgentId(workdir, taskId) {
   const path = registryPath(workdir, taskId);
-  if (!existsSync3(path)) return;
+  if (!existsSync4(path)) return;
   syncWebIdeTaskState(workdir, taskId, { agentId: "" });
 }
 
 // src/commands/clean-webide-cache.ts
-import { existsSync as existsSync4, rmSync } from "node:fs";
-import { resolve as resolve5 } from "node:path";
+import { existsSync as existsSync5, rmSync } from "node:fs";
+import { resolve as resolve6 } from "node:path";
 import { getDefaultSdkStateRoot } from "@cursor/sdk";
 async function purgeCursorAgentStoreForAgent(workdir, agentId) {
   const trimmedAgentId = agentId.trim();
   const trimmedWorkdir = workdir.trim();
   if (!trimmedAgentId || !trimmedWorkdir) return false;
   const stateRoot = getDefaultSdkStateRoot(trimmedWorkdir);
-  if (!existsSync4(stateRoot)) return false;
+  if (!existsSync5(stateRoot)) return false;
   const { SqliteLocalAgentStore } = await import(
     /* @vite-ignore */
     "@cursor/sdk/sqlite"
@@ -1963,8 +2385,8 @@ async function cleanWebIdeWorkspaceCache(taskId, workdir) {
       `[apm] \u65E0 WebIDE agentId\uFF0C\u8DF3\u8FC7 agent store \u6E05\u7406 taskId=${trimmedTaskId}`
     );
   }
-  const dir = resolve5(trimmedWorkdir, ".apm", "webide", trimmedTaskId);
-  if (existsSync4(dir)) {
+  const dir = resolve6(trimmedWorkdir, ".apm", "webide", trimmedTaskId);
+  if (existsSync5(dir)) {
     rmSync(dir, { recursive: true, force: true });
     console.log(`[apm] \u5DF2\u6E05\u7406 WebIDE \u7F13\u5B58 ${dir}`);
   } else {
@@ -1975,11 +2397,11 @@ async function cleanWebIdeWorkspaceCache(taskId, workdir) {
 // src/commands/connect/webide-ask-question.ts
 import { setTimeout as delay } from "node:timers/promises";
 var POLL_INTERVAL_MS = 2e3;
-function asString3(value) {
+function asString4(value) {
   return typeof value === "string" ? value.trim() : "";
 }
 function parseQuestions(args) {
-  const title = asString3(args.title) || void 0;
+  const title = asString4(args.title) || void 0;
   const raw = args.questions;
   if (!Array.isArray(raw) || raw.length === 0) {
     throw new Error("AskQuestion \u7F3A\u5C11 questions");
@@ -1988,16 +2410,16 @@ function parseQuestions(args) {
   for (const item of raw) {
     if (!item || typeof item !== "object" || Array.isArray(item)) continue;
     const row = item;
-    const id = asString3(row.id);
-    const prompt = asString3(row.prompt);
+    const id = asString4(row.id);
+    const prompt = asString4(row.prompt);
     const optionsRaw = row.options;
     if (!id || !prompt || !Array.isArray(optionsRaw)) continue;
     const options = [];
     for (const opt of optionsRaw) {
       if (!opt || typeof opt !== "object" || Array.isArray(opt)) continue;
       const o = opt;
-      const oid = asString3(o.id);
-      const label = asString3(o.label);
+      const oid = asString4(o.id);
+      const label = asString4(o.label);
       if (oid && label) options.push({ id: oid, label });
     }
     if (options.length < 2) {
@@ -2128,12 +2550,12 @@ async function putDirtyEvents(minio, bucket, prefix, events) {
     });
   }
 }
-async function upsertLogHeader(cfg, ctx, patch) {
+async function upsertLogHeader(cfg, ctx, patch, objectPrefix) {
   const api = createApmApiClient(cfg);
   await api.cli.webideUpsertMessageLog({
     messageId: ctx.messageId,
     agentId: ctx.agentId,
-    objectPrefix: webIdeEventsObjectPrefix(ctx.taskId, ctx.messageId),
+    objectPrefix,
     ...patch
   });
 }
@@ -2145,6 +2567,7 @@ function createThrottledWebIdeMessageLogSync(cfg, ctx, onError, options) {
   let minio;
   let bucket = "";
   let firstLogNotified = false;
+  const resolvePrefix = () => options?.objectPrefixOverride?.trim() || webIdeEventsObjectPrefix(ctx.taskId, ctx.messageId);
   const ensureMinio = async () => {
     if (minio) return;
     const created = await createApmLogMinioClient(cfg);
@@ -2168,11 +2591,16 @@ function createThrottledWebIdeMessageLogSync(cfg, ctx, onError, options) {
     lastRunAt = Date.now();
     try {
       await ensureMinio();
-      const prefix = webIdeEventsObjectPrefix(ctx.taskId, ctx.messageId);
+      const prefix = resolvePrefix();
       await putDirtyEvents(minio, bucket, prefix, events);
-      await upsertLogHeader(cfg, ctx, {
-        eventCount: session.getEventCount()
-      });
+      await upsertLogHeader(
+        cfg,
+        ctx,
+        {
+          eventCount: session.getEventCount()
+        },
+        prefix
+      );
       session.clearDirtyIfUnchanged(events);
       await notifyFirstLog();
     } catch (err) {
@@ -2190,12 +2618,17 @@ function createThrottledWebIdeMessageLogSync(cfg, ctx, onError, options) {
   return {
     async markRun(runId, runStatus, lastError, tokenUsage) {
       try {
-        await upsertLogHeader(cfg, ctx, {
-          runId,
-          runStatus,
-          lastError: lastError ?? null,
-          ...tokenUsage ? { tokenUsage } : {}
-        });
+        await upsertLogHeader(
+          cfg,
+          ctx,
+          {
+            runId,
+            runStatus,
+            lastError: lastError ?? null,
+            ...tokenUsage ? { tokenUsage } : {}
+          },
+          resolvePrefix()
+        );
       } catch (err) {
         onError(err);
       }
@@ -2490,14 +2923,14 @@ async function ensureWebIdePullRequests(cfg, taskId, workdir) {
 }
 
 // src/version.ts
-import { readFileSync as readFileSync4 } from "fs";
+import { readFileSync as readFileSync5 } from "fs";
 import { dirname as dirname4, join as join4 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 function readCliVersion() {
   try {
     const dir = dirname4(fileURLToPath2(import.meta.url));
     const pkgPath = join4(dir, "..", "package.json");
-    const pkg = JSON.parse(readFileSync4(pkgPath, "utf8"));
+    const pkg = JSON.parse(readFileSync5(pkgPath, "utf8"));
     return pkg.version ?? "0.0.0";
   } catch {
     return "0.0.0";
@@ -2505,7 +2938,7 @@ function readCliVersion() {
 }
 
 // src/commands/sync-webide-attachments.ts
-import { existsSync as existsSync5, readFileSync as readFileSync5, writeFileSync as writeFileSync4 } from "fs";
+import { existsSync as existsSync6, readFileSync as readFileSync6, writeFileSync as writeFileSync4 } from "fs";
 import { join as join5 } from "path";
 var MANIFEST_FILE = ".sync-manifest.json";
 async function downloadAttachment(cfg, attachmentId) {
@@ -2523,12 +2956,12 @@ async function downloadAttachment(cfg, attachmentId) {
 }
 function loadManifest(dir) {
   const path = join5(dir, MANIFEST_FILE);
-  if (!existsSync5(path)) {
+  if (!existsSync6(path)) {
     return { version: 1, attachments: {} };
   }
   try {
     const parsed = JSON.parse(
-      readFileSync5(path, "utf8")
+      readFileSync6(path, "utf8")
     );
     if (parsed?.version === 1 && parsed.attachments && typeof parsed.attachments === "object") {
       return parsed;
@@ -2546,7 +2979,7 @@ function saveManifest(dir, manifest) {
   );
 }
 function isAttachmentUpToDate(entry, item, dest) {
-  if (!entry || !existsSync5(dest)) return false;
+  if (!entry || !existsSync6(dest)) return false;
   if (entry.name !== item.name) return false;
   const createdAt = item.createdAt ?? "";
   return entry.createdAt === createdAt;
@@ -2593,14 +3026,14 @@ async function syncWebIdeAttachments(cfg, taskId, workdir, attachments) {
 
 // src/utils/project-documents.ts
 import {
-  existsSync as existsSync6,
+  existsSync as existsSync7,
   readdirSync as readdirSync3,
-  readFileSync as readFileSync6,
+  readFileSync as readFileSync7,
   rmSync as rmSync2,
   writeFileSync as writeFileSync5
 } from "fs";
 import { createHash } from "crypto";
-import { dirname as dirname5, join as join6, relative as relative2, sep } from "path";
+import { dirname as dirname5, join as join6, relative as relative3, sep } from "path";
 var MANIFEST_FILE2 = "manifest.json";
 function normalizeProjectIdForPath(projectId) {
   const id = projectId.trim();
@@ -2642,12 +3075,12 @@ function readLocalManifest(apmRoot, projectId) {
     projectDocumentsDir(apmRoot, projectId),
     MANIFEST_FILE2
   );
-  if (!existsSync6(manifestPath3)) {
+  if (!existsSync7(manifestPath3)) {
     return null;
   }
   try {
     return JSON.parse(
-      readFileSync6(manifestPath3, "utf8")
+      readFileSync7(manifestPath3, "utf8")
     );
   } catch {
     return null;
@@ -2655,7 +3088,7 @@ function readLocalManifest(apmRoot, projectId) {
 }
 function listLocalDocumentPaths(apmRoot, projectId) {
   const root = projectDocumentsDir(apmRoot, projectId);
-  if (!existsSync6(root)) {
+  if (!existsSync7(root)) {
     return [];
   }
   const paths = [];
@@ -2669,7 +3102,7 @@ function listLocalDocumentPaths(apmRoot, projectId) {
       if (entry.isFile() && entry.name === MANIFEST_FILE2) {
         continue;
       }
-      const rel = relative2(root, abs).split(sep).join("/");
+      const rel = relative3(root, abs).split(sep).join("/");
       paths.push(rel);
     }
   };
@@ -2790,7 +3223,7 @@ ${diagnostic ?? ""}`);
     const absPath = toFsPath(
       projectDocumentLocalPath(targetApmDir, projectId, path)
     );
-    if (existsSync6(absPath)) {
+    if (existsSync7(absPath)) {
       rmSync2(absPath, { force: true });
       deleted += 1;
     }
@@ -2839,7 +3272,7 @@ async function syncProjectDocumentsPush(cfg, workdirPath, apmRoot, options) {
     const absPath = toFsPath(
       projectDocumentLocalPath(targetApmDir, projectId, path)
     );
-    const content = readFileSync6(absPath, "utf8");
+    const content = readFileSync7(absPath, "utf8");
     const contentHash = hashLocalFileContent(content);
     if (remoteHashByPath.get(path) === contentHash) {
       continue;
@@ -2860,7 +3293,7 @@ async function syncProjectDocumentsPush(cfg, workdirPath, apmRoot, options) {
 }
 
 // src/commands/connect/cli-version-sync.ts
-import { existsSync as existsSync7, readFileSync as readFileSync7, writeFileSync as writeFileSync6 } from "fs";
+import { existsSync as existsSync8, readFileSync as readFileSync8, writeFileSync as writeFileSync6 } from "fs";
 import { join as join7 } from "path";
 var CLI_VERSION_FILE = ".cli-version.json";
 function manifestPath2(apmDir) {
@@ -2868,12 +3301,12 @@ function manifestPath2(apmDir) {
 }
 function loadManifest2(apmDir) {
   const path = toFsPath(manifestPath2(apmDir));
-  if (!existsSync7(path)) {
+  if (!existsSync8(path)) {
     return null;
   }
   try {
     const parsed = JSON.parse(
-      readFileSync7(path, "utf8")
+      readFileSync8(path, "utf8")
     );
     if (parsed?.version === 1 && typeof parsed.cliVersion === "string" && parsed.cliVersion.trim()) {
       return parsed;
@@ -2909,6 +3342,24 @@ function markSkillsSyncedForCliVersion(workdir, cliVersion) {
   syncedInSession.set(workdir, cliVersion);
 }
 
+// src/commands/connect/parse-webide-prompt-payload.ts
+function parseWebIdePromptPayload(content) {
+  const marker = "\n\npayload=";
+  const index = content.lastIndexOf(marker);
+  if (index < 0) return null;
+  const jsonText = content.slice(index + marker.length).trim();
+  if (!jsonText) return null;
+  try {
+    const parsed = JSON.parse(jsonText);
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+      return parsed;
+    }
+  } catch {
+    return null;
+  }
+  return null;
+}
+
 // src/commands/connect/handle-webide-message.ts
 var WEBIDE_CODE_CHANGE_ACTIONS = /* @__PURE__ */ new Set([
   "skip-plan",
@@ -2924,6 +3375,9 @@ function shouldCommitAfterWebIdeMessage(action) {
 function isStartLocalServicesAction(action) {
   return action === "enter-manual-test" || action === "skip-test";
 }
+function isExecuteSqlAction(action) {
+  return action === "execute-sql";
+}
 function syncLocalTaskStatus(workdir, taskId, msg, status) {
   syncWebIdeTaskState(workdir, taskId, {
     messageId: msg.messageId,
@@ -3133,7 +3587,10 @@ async function handleWebIdeInboundMessage(cfg, msg, signal) {
     );
     await syncPrepLog();
     const startLocalServices = isStartLocalServicesAction(msg.action);
+    const executeSql = isExecuteSqlAction(msg.action);
     const savedAgentId = startLocalServices ? void 0 : loadWebIdeAgentId(workdir, taskId);
+    const promptPayload = executeSql ? parseWebIdePromptPayload(msg.content) : null;
+    const sqlExecutionId = executeSql && typeof promptPayload?.executionId === "string" ? promptPayload.executionId.trim() : void 0;
     const outcome = await runCursorAgent(
       cfg,
       {
@@ -3155,9 +3612,11 @@ async function handleWebIdeInboundMessage(cfg, msg, signal) {
           taskId,
           signal
         }),
-        enableAskQuestion: !startLocalServices,
-        enableWebIdePlanTools: !startLocalServices,
+        enableAskQuestion: !startLocalServices && !executeSql,
+        enableWebIdePlanTools: !startLocalServices && !executeSql,
         enablePtySessionMcp: startLocalServices,
+        enableMysqlTools: executeSql,
+        sqlExecutionId,
         enableSandbox: false,
         onInvalidatePersistedAgentId: startLocalServices ? void 0 : () => clearWebIdeAgentId(workdir, taskId),
         taskId,
@@ -3214,6 +3673,20 @@ async function handleWebIdeInboundMessage(cfg, msg, signal) {
         detail,
         tokenUsage
       );
+      if (executeSql && sqlExecutionId) {
+        try {
+          await api.cli.webideFinalizeSqlExecution({
+            executionId: sqlExecutionId,
+            status: "FAILED",
+            error: detail
+          });
+        } catch (finalizeErr) {
+          console.warn(
+            "[apm] finalize sql execution failed:",
+            finalizeErr instanceof Error ? finalizeErr.message : finalizeErr
+          );
+        }
+      }
       await setError(cfg, messageId, detail);
       syncLocalTaskStatus(workdir, taskId, msg, "FAILED");
       return;
@@ -3225,6 +3698,20 @@ async function handleWebIdeInboundMessage(cfg, msg, signal) {
         "\u5DF2\u53D6\u6D88",
         tokenUsage
       );
+      if (executeSql && sqlExecutionId) {
+        try {
+          await api.cli.webideFinalizeSqlExecution({
+            executionId: sqlExecutionId,
+            status: "CANCELLED",
+            error: "\u5DF2\u53D6\u6D88"
+          });
+        } catch (finalizeErr) {
+          console.warn(
+            "[apm] finalize sql execution cancelled:",
+            finalizeErr instanceof Error ? finalizeErr.message : finalizeErr
+          );
+        }
+      }
       await updateStatus(cfg, messageId, "CANCELLED");
       syncLocalTaskStatus(workdir, taskId, msg, "CANCELLED");
       return;
@@ -3501,6 +3988,276 @@ async function handleStartProject(cfg, msg, signal) {
   }
 }
 
+// src/commands/connect/handle-package.ts
+async function updatePackageStatus(cfg, packageId, status, extra) {
+  const api = createApmApiClient(cfg);
+  await api.cli.projectPackageUpdateStatus({
+    id: packageId,
+    status,
+    ...extra?.error != null ? { error: extra.error } : {},
+    ...extra?.content != null ? { content: extra.content } : {},
+    ...extra?.artifactPath != null ? { artifactPath: extra.artifactPath } : {}
+  });
+}
+function expectedArtifactPath(target, packageId) {
+  if (target === "frontend") {
+    return `/data/artifacts/vue/${packageId}/dist.zip`;
+  }
+  return `/data/artifacts/springboot/${packageId}/manifest.json`;
+}
+async function handleWebIdePackage(cfg, msg, signal) {
+  const workdir = requireRemoteWorkdir(msg.workdir);
+  const messageId = msg.messageId;
+  const packageId = msg.packageId;
+  const projectId = msg.projectId;
+  console.log(
+    `[apm] webide-package target=${msg.target} packageId=${packageId} projectId=${projectId} baseBranch=${msg.baseBranch}`
+  );
+  await updatePackageStatus(cfg, packageId, "RUNNING");
+  const eventSession = new EventSession(msg.content);
+  const logSyncRef = {
+    current: createThrottledWebIdeMessageLogSync(
+      cfg,
+      {
+        taskId: `package:${packageId}`,
+        messageId,
+        agentId: "webide-package"
+      },
+      (err) => {
+        console.warn(
+          "[apm] WebIDE \u6253\u5305\u65E5\u5FD7\u540C\u6B65\u5931\u8D25:",
+          err instanceof Error ? err.message : err
+        );
+      },
+      {
+        objectPrefixOverride: `events/webide-package/${packageId}/`
+      }
+    )
+  };
+  const syncPrepLog = async () => {
+    const sync = logSyncRef.current;
+    if (!sync) return;
+    sync.schedule(eventSession);
+    await sync.flush(eventSession);
+  };
+  const runPrepStep = async (step, work, formatOk) => {
+    eventSession.addCliStep(step, "\u8FDB\u884C\u4E2D\u2026", "running");
+    await syncPrepLog();
+    try {
+      const result = await work();
+      eventSession.addCliStep(step, formatOk(result), "ok");
+      await syncPrepLog();
+      return result;
+    } catch (err) {
+      const detail = err instanceof Error ? err.message : String(err);
+      eventSession.addCliStep(step, detail, "error");
+      await syncPrepLog();
+      throw err;
+    }
+  };
+  try {
+    if (signal.aborted) throw new Error("\u4EFB\u52A1\u5DF2\u53D6\u6D88");
+    await runPrepStep(
+      "\u521D\u59CB\u5316\u5DE5\u4F5C\u533A",
+      async () => {
+        const { didInit } = await ensureWorkspaceInitialized(workdir);
+        return didInit;
+      },
+      (didInit) => didInit ? "\u5DF2\u521D\u59CB\u5316\u5DE5\u4F5C\u533A" : "\u5DE5\u4F5C\u533A\u5DF2\u5C31\u7EEA"
+    );
+    const cliVersion = readCliVersion();
+    if (shouldSyncSkillsForCliVersion(workdir, cliVersion)) {
+      if (signal.aborted) throw new Error("\u4EFB\u52A1\u5DF2\u53D6\u6D88");
+      await runPrepStep(
+        "\u540C\u6B65 WebIDE \u89C4\u5219",
+        async () => {
+          await copyWebIdeTemplateFiles(workspaceApmDir(workdir), workdir);
+          markSkillsSyncedForCliVersion(workdir, cliVersion);
+          return cliVersion;
+        },
+        (version) => `\u5DF2\u540C\u6B65\u81F3 CLI ${version}`
+      );
+    } else {
+      eventSession.addCliStep(
+        "\u540C\u6B65 WebIDE \u89C4\u5219",
+        `\u7248\u672C\u4E00\u81F4\uFF08${cliVersion}\uFF09\uFF0C\u8DF3\u8FC7`,
+        "skip"
+      );
+      await syncPrepLog();
+    }
+    await runPrepStep(
+      "\u5DE5\u4F5C\u533A\u4ED3\u5E93\u6E05\u5355",
+      async () => {
+        const workspaceRepos = resolveWorkspaceRepos(workdir);
+        try {
+          await enrichWorkspaceReposRemoteUrls(workspaceRepos);
+        } catch (err) {
+          console.warn(
+            "[apm] \u8865\u9F50 workspace-repos remoteUrl \u5931\u8D25:",
+            err instanceof Error ? err.message : err
+          );
+        }
+        return workspaceRepos;
+      },
+      (repos) => `kind=${repos.kind} repos=${repos.repos.length}`
+    );
+    if (signal.aborted) throw new Error("\u4EFB\u52A1\u5DF2\u53D6\u6D88");
+    await runPrepStep(
+      "\u5207\u6362\u57FA\u7EBF\u5206\u652F",
+      async () => checkoutBaselineBranches(msg.baseBranch, { cwd: workdir }),
+      (result) => `baseline=${result.baseline} kind=${result.kind} repos=${result.repos.length}`
+    );
+    if (signal.aborted) throw new Error("\u4EFB\u52A1\u5DF2\u53D6\u6D88");
+    await runPrepStep(
+      "\u540C\u6B65\u9879\u76EE\u6587\u6863",
+      async () => {
+        const docs = await syncProjectDocumentsPull(workdir, void 0, {
+          projectId
+        });
+        return docs;
+      },
+      (result) => {
+        if (!result.synced) {
+          return result.projectId ? "\u65E0\u9700\u540C\u6B65\u6216\u8DF3\u8FC7" : "\u8DF3\u8FC7\uFF1A\u65E0 projectId";
+        }
+        return `downloaded=${result.downloaded} deleted=${result.deleted}`;
+      }
+    );
+    eventSession.addCliStep("\u542F\u52A8\u6253\u5305 Agent", "\u51C6\u5907 create\u2026", "running");
+    await syncPrepLog();
+    const artifactHint = expectedArtifactPath(msg.target, packageId);
+    let failedByTool = false;
+    const outcome = await runCursorAgent(
+      cfg,
+      {
+        messageId,
+        prompt: msg.content,
+        model: msg.model,
+        apiKey: msg.apiKey,
+        workdir,
+        user: msg.user || "webide"
+      },
+      {
+        signal,
+        forceSend: true,
+        eventSession,
+        enableAppendMessage: false,
+        enableAskQuestion: false,
+        enableWebIdePlanTools: false,
+        enablePtySessionMcp: false,
+        enableSandbox: false,
+        enablePackageStatusTools: true,
+        packageId,
+        onPackageFailed: async () => {
+          failedByTool = true;
+        },
+        taskId: `package:${packageId}`,
+        createRemoteLogSync: (agentId) => {
+          logSyncRef.current = createThrottledWebIdeMessageLogSync(
+            cfg,
+            {
+              taskId: `package:${packageId}`,
+              messageId,
+              agentId
+            },
+            (err) => {
+              console.warn(
+                "[apm] WebIDE \u6253\u5305\u65E5\u5FD7\u540C\u6B65\u5931\u8D25:",
+                err instanceof Error ? err.message : err
+              );
+            },
+            {
+              objectPrefixOverride: `events/webide-package/${packageId}/`
+            }
+          );
+          return logSyncRef.current;
+        },
+        onRunStarted: async ({ agentId, runId }) => {
+          eventSession.addCliStep(
+            "\u542F\u52A8\u6253\u5305 Agent",
+            `agentId=${agentId} runId=${runId}`,
+            "ok"
+          );
+          logSyncRef.current?.schedule(eventSession);
+          await logSyncRef.current?.markRun(runId, "running");
+          await logSyncRef.current?.flush(eventSession);
+        }
+      }
+    );
+    const tokenUsage = outcome.usage != null ? {
+      modelId: outcome.modelId ?? (msg.model?.trim() || void 0),
+      inputTokens: outcome.usage.inputTokens,
+      outputTokens: outcome.usage.outputTokens,
+      cacheReadTokens: outcome.usage.cacheReadTokens,
+      cacheWriteTokens: outcome.usage.cacheWriteTokens,
+      totalTokens: outcome.usage.totalTokens,
+      ...outcome.usage.reasoningTokens != null ? { reasoningTokens: outcome.usage.reasoningTokens } : {}
+    } : void 0;
+    if (outcome.status === "error") {
+      const detail = formatCursorRunFailure(outcome.runId, {
+        resultText: outcome.result
+      });
+      await logSyncRef.current?.markRun(
+        outcome.runId,
+        "error",
+        detail,
+        tokenUsage
+      );
+      if (!failedByTool) {
+        await updatePackageStatus(cfg, packageId, "FAILED", { error: detail });
+      }
+      return;
+    }
+    if (outcome.status === "cancelled" || signal.aborted) {
+      await logSyncRef.current?.markRun(
+        outcome.runId,
+        "cancelled",
+        "\u5DF2\u53D6\u6D88",
+        tokenUsage
+      );
+      await updatePackageStatus(cfg, packageId, "CANCELLED", {
+        error: "\u5DF2\u53D6\u6D88"
+      });
+      return;
+    }
+    await logSyncRef.current?.markRun(
+      outcome.runId,
+      "finished",
+      null,
+      tokenUsage
+    );
+    if (failedByTool) {
+      console.log(
+        `[apm] webide-package Agent \u5DF2\u6807 FAILED packageId=${packageId}`
+      );
+      return;
+    }
+    await updatePackageStatus(cfg, packageId, "SUCCESS", {
+      artifactPath: artifactHint
+    });
+    console.log(
+      `[apm] webide-package \u5B8C\u6210 target=${msg.target} packageId=${packageId} agentId=${outcome.agentId}`
+    );
+  } catch (err) {
+    const detail = err instanceof Error ? err.message : String(err);
+    console.error(`[apm] webide-package \u5931\u8D25: ${detail}`);
+    try {
+      if (signal.aborted) {
+        await updatePackageStatus(cfg, packageId, "CANCELLED", {
+          error: detail
+        });
+      } else {
+        await updatePackageStatus(cfg, packageId, "FAILED", { error: detail });
+      }
+    } catch (statusErr) {
+      console.error(
+        "[apm] \u5199\u5165\u6253\u5305 FAILED \u5931\u8D25:",
+        statusErr instanceof Error ? statusErr.message : statusErr
+      );
+    }
+  }
+}
+
 // src/commands/connect/webide-message-worker.ts
 var controllers = /* @__PURE__ */ new Map();
 async function runJob(cfg, msg) {
@@ -3509,6 +4266,8 @@ async function runJob(cfg, msg) {
   try {
     if (msg.type === "webide-start-project") {
       await handleStartProject(cfg, msg, controller.signal);
+    } else if (msg.type === "webide-package") {
+      await handleWebIdePackage(cfg, msg, controller.signal);
     } else {
       await handleWebIdeInboundMessage(cfg, msg, controller.signal);
     }