ai-project-manage-cli 7.0.9 → 7.1.2

package/dist/webide-message-worker.js

@@ -0,0 +1,2036 @@
+// src/commands/connect/webide-message-worker.ts
+import { parentPort, workerData } from "node:worker_threads";
+
+// src/api/client.ts
+import { createApiClient } from "listpage-http";
+
+// src/api/request-config.ts
+import { defineEndpoint } from "listpage-http";
+var requestConfig = {
+  cli: {
+    me: defineEndpoint(
+      {
+        method: "GET",
+        path: "/cli/me"
+      }
+    ),
+    sessionDetail: defineEndpoint({
+      method: "GET",
+      path: "/cli/sessions/detail"
+    }),
+    sessionMembers: defineEndpoint({
+      method: "GET",
+      path: "/cli/sessions/members"
+    }),
+    listSessionMessages: defineEndpoint({
+      method: "GET",
+      path: "/cli/messages"
+    }),
+    listDocuments: defineEndpoint({
+      method: "GET",
+      path: "/cli/documents"
+    }),
+    getDevGate: defineEndpoint({
+      method: "GET",
+      path: "/cli/dev-gate"
+    }),
+    listAttachments: defineEndpoint(
+      {
+        method: "GET",
+        path: "/cli/attachments"
+      }
+    ),
+    upsertDocument: defineEndpoint({
+      method: "PUT",
+      path: "/cli/documents/upsert"
+    }),
+    appendMessageContent: defineEndpoint({
+      method: "PUT",
+      path: "/cli/messages/content"
+    }),
+    setMessageError: defineEndpoint({
+      method: "PUT",
+      path: "/cli/messages/error"
+    }),
+    upsertCursorMessageLog: defineEndpoint({
+      method: "PUT",
+      path: "/cli/cursor-message-logs"
+    }),
+    updateMessageStatus: defineEndpoint({
+      method: "PUT",
+      path: "/cli/messages/status"
+    }),
+    webideAppendMessageContent: defineEndpoint({
+      method: "PUT",
+      path: "/cli/webide/messages/content"
+    }),
+    webideEnsureMessageContent: defineEndpoint({
+      method: "PUT",
+      path: "/cli/webide/messages/ensure-content"
+    }),
+    webideSetMessageError: defineEndpoint({
+      method: "PUT",
+      path: "/cli/webide/messages/error"
+    }),
+    webideUpdateMessageStatus: defineEndpoint({
+      method: "PUT",
+      path: "/cli/webide/messages/status"
+    }),
+    webideUpsertMessageLog: defineEndpoint({
+      method: "PUT",
+      path: "/cli/webide/message-logs"
+    }),
+    webideReplaceAssumptions: defineEndpoint({
+      method: "PUT",
+      path: "/cli/webide/assumptions"
+    }),
+    webideListAssumptions: defineEndpoint({
+      method: "GET",
+      path: "/cli/webide/assumptions"
+    }),
+    branchBaseline: defineEndpoint({
+      method: "GET",
+      path: "/cli/tasks/branch-baseline"
+    }),
+    listSessionsForBranchCleanup: defineEndpoint({
+      method: "GET",
+      path: "/cli/sessions/branch-cleanup"
+    }),
+    workspaceBaseline: defineEndpoint({
+      method: "GET",
+      path: "/cli/workspaces/baseline"
+    }),
+    getDeploymentConfiguration: defineEndpoint({
+      method: "GET",
+      path: "/cli/deployment-configurations"
+    }),
+    matchRepository: defineEndpoint({
+      method: "GET",
+      path: "/cli/repositories/match"
+    }),
+    listSkills: defineEndpoint({
+      method: "GET",
+      path: "/cli/skills"
+    }),
+    listRules: defineEndpoint({
+      method: "GET",
+      path: "/cli/rules"
+    }),
+    createPullRequest: defineEndpoint({
+      method: "POST",
+      path: "/cli/pull-requests"
+    }),
+    getRepositoryProjectDocumentManifest: defineEndpoint({
+      method: "GET",
+      path: "/cli/repository-project-documents/manifest"
+    }),
+    listRepositoryProjectDocuments: defineEndpoint({
+      method: "GET",
+      path: "/cli/repository-project-documents"
+    }),
+    upsertRepositoryProjectDocument: defineEndpoint({
+      method: "PUT",
+      path: "/cli/repository-project-documents/upsert"
+    }),
+    removeRepositoryProjectDocument: defineEndpoint({
+      method: "DELETE",
+      path: "/cli/repository-project-documents"
+    }),
+    createTaskDeployment: defineEndpoint({
+      method: "POST",
+      path: "/cli/task-deployments"
+    }),
+    updateTaskDeploymentStatus: defineEndpoint({
+      method: "PUT",
+      path: "/cli/task-deployments/status"
+    }),
+    syncTaskDeploymentLog: defineEndpoint({
+      method: "PUT",
+      path: "/cli/task-deployments/log"
+    }),
+    completeTaskDeployment: defineEndpoint({
+      method: "PUT",
+      path: "/cli/task-deployments/complete"
+    }),
+    getDeployArtifactStorage: defineEndpoint(
+      {
+        method: "GET",
+        path: "/cli/deploy-artifact-storage"
+      }
+    ),
+    attachTaskDeploymentArtifact: defineEndpoint({
+      method: "PUT",
+      path: "/cli/task-deployments/artifact"
+    })
+  }
+};
+
+// src/config.ts
+import { mkdirSync, readFileSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+var APM_CONFIG_DIR = join(homedir(), ".config", "apm");
+var APM_CONFIG_PATH = join(APM_CONFIG_DIR, "config.json");
+function resolveClientMachineId(cfg) {
+  return (cfg.clientMachineId ?? cfg.userId ?? "").trim();
+}
+function resolveApiKey(cfg) {
+  return (cfg.apiKey ?? cfg.token ?? "").trim();
+}
+async function tryReadApmConfig() {
+  try {
+    const raw = readFileSync(APM_CONFIG_PATH, "utf8");
+    const v = JSON.parse(raw);
+    if (typeof v !== "object" || v === null) {
+      return null;
+    }
+    const rawCfg = v;
+    if (typeof rawCfg.baseUrl !== "string") {
+      return null;
+    }
+    const apiKey = resolveApiKey(rawCfg);
+    if (!apiKey) return null;
+    const cfg = v;
+    const clientMachineId = resolveClientMachineId(cfg);
+    return {
+      baseUrl: cfg.baseUrl.trim().replace(/\/+$/, ""),
+      apiKey,
+      ...clientMachineId ? { clientMachineId } : {}
+    };
+  } catch {
+    return null;
+  }
+}
+
+// src/api/client.ts
+function createApmApiClient(cfg) {
+  const baseURL = `${cfg.baseUrl.trim().replace(/\/+$/, "")}/api/v1`;
+  return createApiClient(requestConfig, {
+    baseURL,
+    getToken: () => resolveApiKey(cfg) || void 0,
+    successCodes: [0],
+    unauthorizedCodes: [401]
+  });
+}
+
+// src/workdir-path.ts
+import { realpathSync } from "fs";
+import { platform } from "os";
+import { resolve } from "path";
+function toFsPath(inputPath) {
+  const absolute = resolve(inputPath);
+  if (platform() !== "win32") return absolute;
+  if (absolute.startsWith("\\\\?\\")) return absolute;
+  const normalized = absolute.replace(/\//g, "\\");
+  if (normalized.startsWith("\\\\")) {
+    return `\\\\?\\UNC\\${normalized.slice(2)}`;
+  }
+  return `\\\\?\\${normalized}`;
+}
+function normalizeWorkdirPath(path) {
+  let normalized = path.trim().replace(/\\/g, "/").normalize("NFC");
+  if (normalized.startsWith("//?/")) {
+    normalized = normalized.slice(4);
+  }
+  const windowsDrive = /^([A-Za-z]:)\/*(.*)$/.exec(normalized);
+  if (windowsDrive) {
+    const drive = windowsDrive[1].toLowerCase();
+    const rest = windowsDrive[2].replace(/\/+/g, "/").replace(/\/$/, "");
+    return rest ? `${drive}/${rest}` : drive;
+  }
+  normalized = normalized.replace(/\/+/g, "/");
+  if (normalized.length > 1 && normalized.endsWith("/")) {
+    normalized = normalized.slice(0, -1);
+  }
+  return normalized;
+}
+function resolveWorkdirPath(cwd = process.cwd()) {
+  const absolute = resolve(cwd);
+  try {
+    return normalizeWorkdirPath(realpathSync.native(absolute));
+  } catch {
+    return normalizeWorkdirPath(absolute);
+  }
+}
+function requireRemoteWorkdir(workdir) {
+  const trimmed = typeof workdir === "string" ? workdir.trim() : "";
+  if (!trimmed) {
+    throw new Error("[apm] \u8FDC\u7A0B\u6D88\u606F\u7F3A\u5C11\u5DE5\u4F5C\u76EE\u5F55 workdir");
+  }
+  return resolveWorkdirPath(trimmed);
+}
+
+// src/commands/connect/cursor-agent.ts
+import {
+  Agent,
+  CursorAgentError
+} from "@cursor/sdk";
+import { setMaxListeners as setMaxListeners2 } from "node:events";
+
+// src/plan-format.ts
+function formatPlanMarkdown(raw) {
+  let text = raw.trim();
+  if (!text) {
+    return text;
+  }
+  if (text.startsWith("{") && text.endsWith("}")) {
+    try {
+      const parsed = JSON.parse(text);
+      if (typeof parsed.plan === "string") {
+        return formatPlanMarkdown(parsed.plan);
+      }
+    } catch {
+    }
+  }
+  if (!text.includes("\n") && text.includes("\\n")) {
+    text = text.replace(/\\n/g, "\n").replace(/\\t/g, "	").replace(/\\"/g, '"').replace(/\\\\/g, "\\");
+  }
+  return text.replace(/\r\n/g, "\n").trimEnd() + "\n";
+}
+
+// src/session-utils.ts
+var EventSession = class {
+  events = [];
+  dirtyIndices = /* @__PURE__ */ new Set();
+  constructor(prompt) {
+    this.events.push({
+      type: "input",
+      content: prompt
+    });
+    this.markDirty(0);
+  }
+  markDirty(index) {
+    this.dirtyIndices.add(index);
+  }
+  addEvent(event) {
+    const latestEvent = this.events[this.events.length - 1];
+    const formatedEvent = this.formatEvent(event);
+    if (!formatedEvent) {
+      return;
+    }
+    if (formatedEvent.type === "tool_call") {
+      const existingIndex = this.events.findIndex(
+        (e) => e.type === "tool_call" && e.call_id === formatedEvent.call_id
+      );
+      if (existingIndex >= 0) {
+        const existingToolCall = this.events[existingIndex];
+        existingToolCall.args = formatedEvent.args;
+        existingToolCall.result = formatedEvent.result;
+        existingToolCall.status = formatedEvent.status;
+        this.markDirty(existingIndex);
+        return;
+      }
+      this.events.push(formatedEvent);
+      this.markDirty(this.events.length - 1);
+      return;
+    }
+    if (formatedEvent.type === "status") {
+      return;
+    }
+    if (formatedEvent.type === "request") {
+      this.events.push(formatedEvent);
+      this.markDirty(this.events.length - 1);
+      return;
+    }
+    if (latestEvent?.type === formatedEvent.type) {
+      switch (formatedEvent.type) {
+        case "assistant":
+          latestEvent.content += formatedEvent.content;
+          break;
+        case "thinking":
+          latestEvent.content += formatedEvent.content;
+          break;
+        case "task":
+          latestEvent.status = formatedEvent.status;
+          latestEvent.text = formatedEvent.text;
+          break;
+      }
+      this.markDirty(this.events.length - 1);
+      return;
+    }
+    this.events.push(formatedEvent);
+    this.markDirty(this.events.length - 1);
+  }
+  formatEvent(event) {
+    switch (event.type) {
+      case "assistant": {
+        let content = "";
+        for (const block of event.message.content) {
+          if (block.type === "text" && block.text) {
+            content += block.text;
+          }
+        }
+        return {
+          type: "assistant",
+          content: content || event.content || ""
+        };
+      }
+      case "thinking":
+        return {
+          type: "thinking",
+          content: event.text || event.content || ""
+        };
+      case "tool_call":
+        return {
+          type: "tool_call",
+          args: event.args,
+          result: event.result,
+          status: event.status,
+          call_id: event.call_id,
+          name: event.name
+        };
+      case "task":
+        return {
+          type: "task",
+          status: event.status,
+          text: event.text
+        };
+      case "request":
+        return {
+          ...event,
+          type: "request"
+        };
+      case "status":
+        return { type: "status", status: event.status, message: event.message };
+    }
+  }
+  getDirtyEvents() {
+    return [...this.dirtyIndices].sort((a, b) => a - b).map((index) => {
+      const event = this.events[index];
+      return {
+        index,
+        type: event.type,
+        data: JSON.stringify(event)
+      };
+    });
+  }
+  clearDirty(indices) {
+    for (const index of indices) {
+      this.dirtyIndices.delete(index);
+    }
+  }
+  getEventCount() {
+    return this.events.length;
+  }
+  /** 合并所有 assistant 片段，供剧场成员回传等场景使用 */
+  getAssistantText() {
+    return this.events.filter((e) => e.type === "assistant").map((e) => String(e.content ?? "")).join("\n").trim();
+  }
+  /** plan 模式下 createPlan 工具 completed 时的 plan 字段（取最后一次） */
+  getCreatePlanContent() {
+    for (let i = this.events.length - 1; i >= 0; i--) {
+      const event = this.events[i];
+      if (event.type !== "tool_call") {
+        continue;
+      }
+      if (event.name !== "createPlan" || event.status !== "completed") {
+        continue;
+      }
+      const plan = event.args?.plan;
+      if (typeof plan === "string" && plan.trim()) {
+        return formatPlanMarkdown(plan);
+      }
+    }
+    return void 0;
+  }
+  resolveLogContent() {
+    return this.events.map((event) => formatLogEvent(event.type, event)).join("\n");
+  }
+};
+function formatLogEvent(type, event) {
+  if (type === "input") {
+    return `## \u7528\u6237\u8F93\u5165
+
+${String(event.content ?? "")}
+`;
+  }
+  if (type === "assistant") {
+    return `## \u6A21\u578B\u8F93\u51FA
+
+${String(event.content ?? "")}
+`;
+  }
+  if (type === "thinking") {
+    return `## \u6A21\u578B\u601D\u8003
+
+${String(event.content ?? "")}
+`;
+  }
+  if (type === "tool_call") {
+    return "````toolcall\n" + JSON.stringify(event, null, 2) + "\n````\n";
+  }
+  return `## \u672A\u77E5\u4E8B\u4EF6\uFF1A${type}
+
+\`\`\`json
+${JSON.stringify(event, null, 2)}
+\`\`\``;
+}
+
+// src/commands/connect/agent-session-registry.ts
+import { existsSync, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "node:fs";
+import { dirname, resolve as resolve2 } from "node:path";
+function registryPath(workdir, sessionId) {
+  return resolve2(workdir, ".apm", "sessions", sessionId, "cursor-agents.json");
+}
+function readRegistry(path) {
+  if (!existsSync(path)) {
+    return {};
+  }
+  try {
+    const parsed = JSON.parse(readFileSync2(path, "utf8"));
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+      const result = {};
+      for (const [key, value] of Object.entries(
+        parsed
+      )) {
+        if (typeof value === "string" && value.trim()) {
+          result[key] = value.trim();
+        }
+      }
+      return result;
+    }
+  } catch {
+  }
+  return {};
+}
+function writeRegistry(path, registry) {
+  mkdirSync2(dirname(path), { recursive: true });
+  writeFileSync2(path, `${JSON.stringify(registry, null, 2)}
+`, "utf8");
+}
+function loadSessionAgentId(workdir, sessionId, user) {
+  const registry = readRegistry(registryPath(workdir, sessionId));
+  return registry[user];
+}
+function saveSessionAgentId(workdir, sessionId, user, agentId) {
+  const path = registryPath(workdir, sessionId);
+  const registry = readRegistry(path);
+  registry[user] = agentId;
+  writeRegistry(path, registry);
+}
+function clearSessionAgentId(workdir, sessionId, user) {
+  const path = registryPath(workdir, sessionId);
+  const registry = readRegistry(path);
+  if (!(user in registry)) {
+    return;
+  }
+  delete registry[user];
+  writeRegistry(path, registry);
+}
+
+// src/commands/connect/cursor-message-log.ts
+var CURSOR_MESSAGE_LOG_SYNC_INTERVAL_MS = 2e3;
+function createThrottledCursorMessageLogSync(cfg, ctx, onError) {
+  let lastRunAt = 0;
+  let timer;
+  let latestSession;
+  let syncChain = Promise.resolve();
+  const syncDirtyEventsOnce = async (session) => {
+    const events = session.getDirtyEvents();
+    if (events.length === 0) {
+      return;
+    }
+    lastRunAt = Date.now();
+    try {
+      await syncCursorMessageLog(cfg, ctx, events);
+      session.clearDirty(events.map((event) => event.index));
+    } catch (err) {
+      onError(err);
+    }
+  };
+  const drainDirtyEvents = async (session) => {
+    while (session.getDirtyEvents().length > 0) {
+      await syncDirtyEventsOnce(session);
+    }
+  };
+  const enqueueSync = (session) => {
+    syncChain = syncChain.then(() => drainDirtyEvents(session));
+  };
+  return {
+    schedule(session) {
+      latestSession = session;
+      const now = Date.now();
+      const elapsed = now - lastRunAt;
+      if (elapsed >= CURSOR_MESSAGE_LOG_SYNC_INTERVAL_MS) {
+        if (timer) {
+          clearTimeout(timer);
+          timer = void 0;
+        }
+        enqueueSync(session);
+        return;
+      }
+      if (timer) {
+        return;
+      }
+      timer = setTimeout(() => {
+        timer = void 0;
+        enqueueSync(latestSession);
+      }, CURSOR_MESSAGE_LOG_SYNC_INTERVAL_MS - elapsed);
+    },
+    async flush(session) {
+      latestSession = session;
+      if (timer) {
+        clearTimeout(timer);
+        timer = void 0;
+      }
+      await syncChain;
+      await drainDirtyEvents(session);
+    }
+  };
+}
+async function syncCursorMessageLog(cfg, ctx, events) {
+  const agentId = ctx.agentId.trim();
+  if (!agentId || events.length === 0) {
+    return;
+  }
+  const api = createApmApiClient(cfg);
+  await api.cli.upsertCursorMessageLog({
+    sessionId: ctx.sessionId,
+    messageId: ctx.messageId,
+    agentId,
+    events
+  });
+}
+
+// src/commands/connect/abort-signal-debug.ts
+import {
+  getEventListeners,
+  getMaxListeners,
+  setMaxListeners
+} from "node:events";
+function isAbortSignalDebugEnabled() {
+  const v = process.env.APM_DEBUG_ABORT_SIGNAL?.trim().toLowerCase();
+  return v === "1" || v === "true" || v === "yes";
+}
+function formatAbortSignalStats(signal, label) {
+  if (!signal) {
+    return `[apm:abort-debug] ${label}: (no signal)`;
+  }
+  const listeners = getEventListeners(signal, "abort");
+  const max = getMaxListeners(signal);
+  return `[apm:abort-debug] ${label}: abortListeners=${listeners.length} maxListeners=${max} aborted=${signal.aborted}`;
+}
+function logAbortSignalStats(signal, label) {
+  if (!isAbortSignalDebugEnabled()) return;
+  console.log(formatAbortSignalStats(signal, label));
+}
+var installed = false;
+function installAbortSignalDebug() {
+  if (!isAbortSignalDebugEnabled() || installed) return;
+  installed = true;
+  const maxFromEnv = Number.parseInt(
+    process.env.APM_ABORT_SIGNAL_MAX_LISTENERS ?? "",
+    10
+  );
+  if (Number.isFinite(maxFromEnv) && maxFromEnv > 0) {
+    setMaxListeners(maxFromEnv);
+    console.log(
+      `[apm:abort-debug] setMaxListeners(${maxFromEnv}) via APM_ABORT_SIGNAL_MAX_LISTENERS`
+    );
+  }
+  process.on("warning", (warning) => {
+    if (warning.name !== "MaxListenersExceededWarning") return;
+    console.warn(`[apm:abort-debug] ${warning.name}: ${warning.message}`);
+    if (warning.stack) {
+      console.warn(warning.stack);
+    }
+  });
+  const proto = AbortSignal.prototype;
+  const original = proto.addEventListener;
+  proto.addEventListener = function(type, listener, options) {
+    if (type === "abort") {
+      const sig = this;
+      const before = getEventListeners(sig, "abort").length;
+      const max = getMaxListeners(sig);
+      const stack = new Error("[apm:abort-debug] addEventListener stack").stack?.split("\n").slice(2, 8).join("\n") ?? "";
+      console.log(
+        `[apm:abort-debug] addEventListener("abort") before=${before} max=${max}
+${stack}`
+      );
+    }
+    return original.call(this, type, listener, options);
+  };
+  console.log(
+    "[apm:abort-debug] \u5DF2\u542F\u7528 AbortSignal \u8C03\u8BD5\uFF08APM_DEBUG_ABORT_SIGNAL\uFF09"
+  );
+}
+
+// src/command-utils.ts
+import {
+  copyFileSync,
+  existsSync as existsSync2,
+  mkdirSync as mkdirSync3,
+  readFileSync as readFileSync3,
+  readdirSync,
+  statSync,
+  writeFileSync as writeFileSync3
+} from "fs";
+import { basename, dirname as dirname2, extname, join as join2, resolve as resolve3 } from "path";
+import { fileURLToPath } from "url";
+var __dirname = dirname2(fileURLToPath(import.meta.url));
+var CLI_TEMPLATE_DIR = resolve3(__dirname, "../template");
+function workspaceApmDir(cwd = resolveWorkdirPath()) {
+  return resolve3(resolve3(cwd), ".apm");
+}
+function isWorkspaceApmInitialized(workdir) {
+  const apmDir = workspaceApmDir(workdir);
+  const fsApmDir = toFsPath(apmDir);
+  if (!existsSync2(fsApmDir)) {
+    return false;
+  }
+  const st = statSync(fsApmDir);
+  if (!st.isDirectory()) {
+    throw new Error(
+      `\u5DE5\u4F5C\u76EE\u5F55 ${workdir} \u4E0B\u7684 .apm \u4E0D\u662F\u76EE\u5F55\uFF0C\u8BF7\u68C0\u67E5\u672C\u5730\u63A5\u5165\u72B6\u6001\u3002`
+    );
+  }
+  return readdirSync(fsApmDir).length > 0;
+}
+var APM_GITIGNORE_PATTERNS = [
+  /^\.apm\/?$/,
+  /^\.apm\/\*\*$/,
+  /^\*\*\/\.apm\/?$/,
+  /^\*\*\/\.apm\/\*\*$/,
+  /^\/\.apm\/?$/,
+  /^\/\.apm\/\*\*$/
+];
+function normalizeGitignorePattern(line) {
+  const trimmed = line.trim();
+  if (!trimmed || trimmed.startsWith("#")) return "";
+  if (trimmed.startsWith("!")) return "";
+  const hashIndex = trimmed.indexOf("#");
+  return (hashIndex >= 0 ? trimmed.slice(0, hashIndex) : trimmed).trim();
+}
+function gitignoreIgnoresApm(line) {
+  const pattern = normalizeGitignorePattern(line);
+  if (!pattern) return false;
+  return APM_GITIGNORE_PATTERNS.some((re) => re.test(pattern));
+}
+var APM_GITIGNORE_LINE = "**/.apm/**";
+function ensureApmGitignoredInRepo(workdir) {
+  const gitignorePath = join2(workdir, ".gitignore");
+  const fsGitignorePath = toFsPath(gitignorePath);
+  if (!existsSync2(fsGitignorePath)) {
+    writeFileSync3(fsGitignorePath, `${APM_GITIGNORE_LINE}
+`, "utf8");
+    return true;
+  }
+  const content = readFileSync3(fsGitignorePath, "utf8");
+  if (content.split(/\r?\n/).some(gitignoreIgnoresApm)) {
+    return false;
+  }
+  const suffix = content.endsWith("\n") || content.length === 0 ? "" : "\n";
+  writeFileSync3(
+    fsGitignorePath,
+    `${content}${suffix}${APM_GITIGNORE_LINE}
+`,
+    "utf8"
+  );
+  return true;
+}
+function assertApmGitignoredInRepo(workdir) {
+  const gitignorePath = join2(workdir, ".gitignore");
+  const fsGitignorePath = toFsPath(gitignorePath);
+  if (!existsSync2(fsGitignorePath)) {
+    throw new Error(
+      `\u5DE5\u4F5C\u76EE\u5F55 ${workdir} \u7F3A\u5C11 .gitignore \u6587\u4EF6\uFF0C\u8BF7\u6DFB\u52A0\u5BF9 .apm \u7684\u5FFD\u7565\u89C4\u5219\uFF08\u4F8B\u5982 **/.apm/**\uFF09\uFF0C\u907F\u514D\u672C\u5730\u4F1A\u8BDD\u4E0E\u90E8\u7F72\u51ED\u636E\u88AB\u63D0\u4EA4\u3002`
+    );
+  }
+  const content = readFileSync3(fsGitignorePath, "utf8");
+  if (!content.split(/\r?\n/).some(gitignoreIgnoresApm)) {
+    throw new Error(
+      `\u5DE5\u4F5C\u76EE\u5F55 ${workdir} \u7684 .gitignore \u672A\u5FFD\u7565 .apm\uFF0C\u8BF7\u6DFB\u52A0 **/.apm/** \u6216 .apm/\uFF0C\u907F\u514D\u672C\u5730\u4F1A\u8BDD\u4E0E\u90E8\u7F72\u51ED\u636E\u88AB\u63D0\u4EA4\u3002`
+    );
+  }
+}
+async function ensureDirExists(dir) {
+  mkdirSync3(dir, { recursive: true });
+}
+async function ensureWorkspaceApmDirForInit(cwd = resolveWorkdirPath()) {
+  const dir = workspaceApmDir(cwd);
+  const fsDir = toFsPath(dir);
+  if (!existsSync2(fsDir)) {
+    mkdirSync3(fsDir, { recursive: true });
+    return;
+  }
+  const st = statSync(fsDir);
+  if (!st.isDirectory()) {
+    throw new Error(`[apm] \u8DEF\u5F84\u5DF2\u5B58\u5728\u4F46\u4E0D\u662F\u76EE\u5F55: ${dir}`);
+  }
+  if (readdirSync(fsDir).length > 0) {
+    throw new Error(
+      "[apm] .apm \u76EE\u5F55\u5DF2\u5B58\u5728\u4E14\u975E\u7A7A\uFF0C\u8BF7\u5148\u5907\u4EFD\u3001\u6E05\u7A7A\u6216\u5220\u9664\u540E\u518D\u6267\u884C init"
+    );
+  }
+}
+var WORKSPACE_TEMPLATE_SUBDIRS = [
+  "sessions",
+  "skills",
+  "rules",
+  "deploy"
+];
+function shouldSkipTemplateEntry(name) {
+  return name === ".DS_Store" || name === "Thumbs.db";
+}
+function copyTemplateEntry(src, dest) {
+  const fsSrc = toFsPath(src);
+  const fsDest = toFsPath(dest);
+  const st = statSync(fsSrc);
+  if (st.isDirectory()) {
+    mkdirSync3(fsDest, { recursive: true });
+    for (const name of readdirSync(fsSrc)) {
+      if (shouldSkipTemplateEntry(name)) continue;
+      copyTemplateEntry(join2(src, name), join2(dest, name));
+    }
+    return;
+  }
+  if (!st.isFile()) return;
+  mkdirSync3(toFsPath(dirname2(dest)), { recursive: true });
+  copyFileSync(fsSrc, fsDest);
+}
+function assertTemplateCopiedToApm(apmDir, workdir) {
+  const required = [
+    "AGENTS.md",
+    "apm.config.json",
+    "rules",
+    "skills",
+    "sessions"
+  ];
+  for (const item of required) {
+    const path = join2(apmDir, item);
+    if (!existsSync2(toFsPath(path))) {
+      throw new Error(`[apm] \u521D\u59CB\u5316\u4E0D\u5B8C\u6574\uFF0C\u7F3A\u5C11: ${path}`);
+    }
+  }
+  const leakedRules = join2(workdir, "rules");
+  const apmRules = join2(apmDir, "rules");
+  if (existsSync2(toFsPath(leakedRules)) && !existsSync2(toFsPath(join2(apmRules, "reply.md")))) {
+    throw new Error(
+      `[apm] \u6A21\u677F\u88AB\u590D\u5236\u5230\u9519\u8BEF\u4F4D\u7F6E: ${leakedRules}\uFF08\u5E94\u5728 ${apmRules}\uFF09`
+    );
+  }
+}
+async function copyTemplateFiles(targetDir, workdir = resolveWorkdirPath()) {
+  const resolvedTarget = resolve3(targetDir);
+  const templateDir = resolve3(CLI_TEMPLATE_DIR);
+  const fsTemplateDir = toFsPath(templateDir);
+  if (!existsSync2(fsTemplateDir)) {
+    throw new Error(`[apm] \u672A\u627E\u5230 CLI \u6A21\u677F\u76EE\u5F55: ${templateDir}`);
+  }
+  const dirStat = statSync(fsTemplateDir);
+  if (!dirStat.isDirectory()) {
+    throw new Error(`[apm] CLI \u6A21\u677F\u8DEF\u5F84\u4E0D\u662F\u76EE\u5F55: ${templateDir}`);
+  }
+  const entries = readdirSync(fsTemplateDir).filter(
+    (name) => !shouldSkipTemplateEntry(name)
+  );
+  if (entries.length === 0) {
+    throw new Error(`[apm] CLI \u6A21\u677F\u76EE\u5F55\u4E3A\u7A7A: ${templateDir}`);
+  }
+  mkdirSync3(toFsPath(resolvedTarget), { recursive: true });
+  for (const name of entries) {
+    copyTemplateEntry(join2(templateDir, name), join2(resolvedTarget, name));
+  }
+  for (const subdir of WORKSPACE_TEMPLATE_SUBDIRS) {
+    mkdirSync3(toFsPath(join2(resolvedTarget, subdir)), { recursive: true });
+  }
+  assertTemplateCopiedToApm(resolvedTarget, resolve3(workdir));
+}
+
+// src/commands/append-message.ts
+async function appendMessageContent(cfg, messageId, content) {
+  const trimmedId = messageId.trim();
+  if (!trimmedId) {
+    throw new Error("messageId \u4E0D\u80FD\u4E3A\u7A7A");
+  }
+  if (!content) {
+    throw new Error("content \u4E0D\u80FD\u4E3A\u7A7A");
+  }
+  const api = createApmApiClient(cfg);
+  await api.cli.appendMessageContent({ id: trimmedId, content });
+}
+
+// src/commands/connect/append-message-tool.ts
+function createAppendMessageCustomTools(cfg, messageId, appendContent2) {
+  const doAppend = appendContent2 ?? ((content) => appendMessageContent(cfg, messageId, content));
+  return {
+    append_message: {
+      description: "\u5411\u5F53\u524D\u4F1A\u8BDD\u6D88\u606F\u8FFD\u52A0\u56DE\u590D\u5185\u5BB9\u3002\u53EF\u591A\u6B21\u8C03\u7528\u8865\u5145\u8FDB\u5C55\uFF1B\u88AB @ \u65F6\u6536\u5230\u540E\u5E94\u5148\u7B80\u77ED\u786E\u8BA4\u518D\u6267\u884C\u4EFB\u52A1\u3002",
+      inputSchema: {
+        type: "object",
+        properties: {
+          content: {
+            type: "string",
+            description: "\u8981\u53D1\u9001\u5230\u7FA4\u91CC\u7684\u56DE\u590D\u5185\u5BB9"
+          }
+        },
+        required: ["content"]
+      },
+      execute: async (args) => {
+        const content = typeof args.content === "string" ? args.content.trim() : "";
+        if (!content) {
+          return {
+            content: [{ type: "text", text: "content \u4E0D\u80FD\u4E3A\u7A7A" }],
+            isError: true
+          };
+        }
+        try {
+          await doAppend(content);
+          console.log(`[apm] append_message \u5DF2\u8FFD\u52A0: messageId=${messageId}`);
+          return "\u5DF2\u8FFD\u52A0\u6D88\u606F\u5185\u5BB9";
+        } catch (err) {
+          const detail = err instanceof Error ? err.message : String(err);
+          return {
+            content: [{ type: "text", text: `\u8FFD\u52A0\u6D88\u606F\u5931\u8D25: ${detail}` }],
+            isError: true
+          };
+        }
+      }
+    }
+  };
+}
+
+// src/commands/connect/ask-question-tool.ts
+var INPUT_SCHEMA = {
+  type: "object",
+  properties: {
+    title: {
+      type: "string",
+      description: "Optional title for the questions form"
+    },
+    questions: {
+      type: "array",
+      minItems: 1,
+      items: {
+        type: "object",
+        properties: {
+          id: { type: "string" },
+          prompt: { type: "string" },
+          allow_multiple: { type: "boolean" },
+          options: {
+            type: "array",
+            minItems: 2,
+            items: {
+              type: "object",
+              properties: {
+                id: { type: "string" },
+                label: { type: "string" }
+              },
+              required: ["id", "label"]
+            }
+          }
+        },
+        required: ["id", "prompt", "options"]
+      }
+    }
+  },
+  required: ["questions"]
+};
+function createAskQuestionTool(options) {
+  return {
+    description: "Collect structured multiple-choice answers from the user. Use when blocked on a decision that is genuinely the user's to make.",
+    inputSchema: INPUT_SCHEMA,
+    execute: async (args) => {
+      options?.onInvoke?.(args);
+      if (options?.execute) {
+        return options.execute(args);
+      }
+      const payload = JSON.stringify(args, null, 2);
+      console.log(`[apm] AskQuestion\uFF08\u672C\u5730\u5360\u4F4D\uFF0C\u672A\u7B49\u5F85\u7528\u6237\uFF09:
+${payload}`);
+      return `[local] AskQuestion \u5DF2\u8BB0\u5F55\uFF08\u672A\u521B\u5EFA\u4EFB\u52A1\u95EE\u9898\u3001\u672A\u7B49\u5F85\u7528\u6237\u56DE\u7B54\uFF09\u3002\u53C2\u6570:
+${payload}`;
+    }
+  };
+}
+
+// src/commands/connect/cursor-custom-tools.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
+\u9700\u8981\u5411\u7528\u6237\u786E\u8BA4\u65F6\uFF0C\u8BF7\u8C03\u7528 AskQuestion\uFF08\u7ECF CallMcpTool / custom-user-tools\uFF09\uFF0C\u4E0D\u8981\u5047\u8BBE IDE \u5185\u7F6E AskQuestion \u4E0D\u53EF\u7528\u3002
+\u975E\u5FC5\u987B\u7684\u95EE\u9898\u53EF\u8DF3\u8FC7\uFF0C\u76F4\u63A5\u5B8C\u6210 createPlan\u3002`;
+function createCursorCustomTools(cfg, messageId, options) {
+  return {
+    ...createAppendMessageCustomTools(
+      cfg,
+      messageId,
+      options?.appendMessageContent
+    ),
+    AskQuestion: createAskQuestionTool({
+      onInvoke: options?.onAskQuestion,
+      execute: options?.askQuestionExecute
+    })
+  };
+}
+function withPlanModeToolHint(prompt, mode) {
+  if (mode !== "plan") {
+    return prompt;
+  }
+  return `${prompt.trim()}
+
+${PLAN_MODE_ASK_QUESTION_HINT}`;
+}
+
+// src/commands/connect/cursor-agent.ts
+setMaxListeners2(100);
+installAbortSignalDebug();
+var noopRemoteLogSync = {
+  schedule(_session) {
+  },
+  async flush(_session) {
+  }
+};
+var logCtx = (ctx, agentId) => ({
+  sessionId: ctx.sessionId,
+  messageId: ctx.messageId,
+  agentId
+});
+function formatCursorRunFailure(runId, options) {
+  const details = [
+    options?.statusError?.trim(),
+    options?.resultText?.trim()
+  ].filter((value, index, arr) => {
+    if (!value) return false;
+    return arr.indexOf(value) === index;
+  });
+  if (details.length === 0) {
+    return `Cursor run \u5931\u8D25: ${runId}`;
+  }
+  return `Cursor run \u5931\u8D25: ${runId} \u2014 ${details.join("\uFF1B")}`;
+}
+async function obtainAgent(ctx) {
+  const agentOptions = {
+    apiKey: ctx.apiKey,
+    model: { id: ctx.model || "default" },
+    local: {
+      cwd: ctx.cwd,
+      ...ctx.customTools ? { customTools: ctx.customTools } : {}
+    },
+    ...ctx.mode ? { mode: ctx.mode } : {}
+    // mcpServers: createPlaywrightMcpServers(),
+  };
+  const explicitAgentId = ctx.resumeAgentId?.trim();
+  const savedAgentId = explicitAgentId || (ctx.user ? loadSessionAgentId(ctx.workdir, ctx.sessionId, ctx.user) : void 0);
+  if (savedAgentId) {
+    try {
+      const agent2 = await Agent.resume(savedAgentId, agentOptions);
+      console.log(
+        `[apm] \u590D\u7528 Agent user=${ctx.user} agentId=${savedAgentId}${explicitAgentId ? "\uFF08\u53C2\u6570\u6307\u5B9A\uFF09" : ""}`
+      );
+      if (ctx.user) {
+        saveSessionAgentId(ctx.workdir, ctx.sessionId, ctx.user, agent2.agentId);
+      }
+      return { agent: agent2, resumed: true };
+    } catch (err) {
+      console.warn(
+        `[apm] \u590D\u7528 Agent \u5931\u8D25\uFF08agentId=${savedAgentId}\uFF09\uFF0C\u56DE\u9000\u4E3A\u65B0\u5EFA:`,
+        err instanceof Error ? err.message : err
+      );
+      if (!explicitAgentId && ctx.user) {
+        clearSessionAgentId(ctx.workdir, ctx.sessionId, ctx.user);
+      }
+    }
+  }
+  const agent = await Agent.create(agentOptions);
+  if (ctx.user) {
+    saveSessionAgentId(ctx.workdir, ctx.sessionId, ctx.user, agent.agentId);
+  }
+  return { agent, resumed: false };
+}
+async function runCursorAgent(cfg, ctx, options) {
+  const signal = options?.signal;
+  logAbortSignalStats(signal, "runCursorAgent:start");
+  if (signal?.aborted) {
+    throw new Error("\u8FDE\u63A5\u5DF2\u5173\u95ED\uFF0C\u4EFB\u52A1\u4E2D\u65AD");
+  }
+  const apiKey = ctx.apiKey.trim();
+  if (!apiKey) {
+    throw new Error("\u7F3A\u5C11 apiKey\uFF0C\u65E0\u6CD5\u8C03\u7528 Cursor SDK");
+  }
+  const workdir = resolveWorkdirPath(ctx.workdir);
+  const customTools = createCursorCustomTools(cfg, ctx.messageId, {
+    onAskQuestion: options?.onAskQuestion,
+    appendMessageContent: options?.appendMessageContent,
+    askQuestionExecute: options?.askQuestionExecute
+  });
+  const prompt = withPlanModeToolHint(ctx.prompt, ctx.mode);
+  console.log(
+    `[apm] Cursor Agent \u5F00\u59CB messageId=${ctx.messageId} sessionId=${ctx.sessionId} cwd=${workdir}`
+  );
+  const { agent, resumed } = await obtainAgent({
+    apiKey,
+    model: ctx.model,
+    cwd: workdir,
+    workdir,
+    sessionId: ctx.sessionId,
+    user: ctx.user,
+    mode: ctx.mode,
+    resumeAgentId: ctx.resumeAgentId,
+    customTools
+  });
+  const eventSession = new EventSession(prompt);
+  const syncRemoteLog = options?.createRemoteLogSync ? options.createRemoteLogSync(agent.agentId) : options?.skipRemoteLogSync ? noopRemoteLogSync : createThrottledCursorMessageLogSync(
+    cfg,
+    logCtx(ctx, agent.agentId),
+    (err) => {
+      console.warn(
+        "[apm] \u540C\u6B65 Cursor \u6D88\u606F\u65E5\u5FD7\u5931\u8D25:",
+        err instanceof Error ? err.message : err
+      );
+    }
+  );
+  let activeRun;
+  const abortRun = () => {
+    if (!activeRun?.supports("cancel")) return;
+    void activeRun.cancel().catch(() => void 0);
+  };
+  signal?.addEventListener("abort", abortRun, { once: true });
+  logAbortSignalStats(signal, "runCursorAgent:after-addListener");
+  try {
+    const run = await agent.send(prompt, {
+      ...ctx.mode ? { mode: ctx.mode } : {},
+      // mcpServers: createPlaywrightMcpServers(),
+      local: {
+        ...options?.forceSend ? { force: true } : {},
+        customTools
+      }
+    });
+    activeRun = run;
+    logAbortSignalStats(signal, "runCursorAgent:after-send");
+    console.log(`[apm] Cursor run id=${run.id} agentId=${agent.agentId}`);
+    await options?.onRunStarted?.({ agentId: agent.agentId, runId: run.id });
+    let lastRunErrorStatus;
+    for await (const event of run.stream()) {
+      if (signal?.aborted) {
+        abortRun();
+        throw new Error("\u8FDE\u63A5\u5DF2\u5173\u95ED\uFF0C\u4EFB\u52A1\u4E2D\u65AD");
+      }
+      if (event.type === "status" && event.status === "ERROR") {
+        const message = event.message?.trim();
+        if (message) {
+          lastRunErrorStatus = message;
+          console.error(
+            `[apm] Cursor run status=ERROR runId=${run.id}: ${message}`
+          );
+        }
+      }
+      options?.onStreamEvent?.(event);
+      eventSession.addEvent(event);
+      syncRemoteLog.schedule(eventSession);
+    }
+    await syncRemoteLog.flush(eventSession);
+    const result = await run.wait();
+    if (result.status === "error") {
+      const failureMessage = formatCursorRunFailure(result.id, {
+        statusError: lastRunErrorStatus,
+        resultText: result.result
+      });
+      console.error(`[apm] ${failureMessage}`);
+      if (resumed) {
+        clearSessionAgentId(workdir, ctx.sessionId, ctx.user);
+      }
+      throw new Error(failureMessage);
+    }
+    if (result.status === "cancelled") {
+      throw new Error(`Cursor run \u5DF2\u53D6\u6D88: ${result.id}`);
+    }
+    console.log(`[apm] Cursor Agent \u5B8C\u6210 messageId=${ctx.messageId}`);
+    const artifacts = await agent.listArtifacts().catch(() => []);
+    const artifactDocuments = [];
+    for (const artifact of artifacts) {
+      try {
+        const content = (await agent.downloadArtifact(artifact.path)).toString(
+          "utf8"
+        );
+        artifactDocuments.push({ path: artifact.path, content });
+      } catch (err) {
+        console.warn(
+          `[apm] \u8BFB\u53D6\u4EA7\u7269\u5931\u8D25 path=${artifact.path}:`,
+          err instanceof Error ? err.message : err
+        );
+      }
+    }
+    return {
+      runId: result.id,
+      agentId: agent.agentId,
+      status: result.status,
+      result: result.result,
+      durationMs: result.durationMs,
+      assistantText: eventSession.getAssistantText(),
+      createPlan: eventSession.getCreatePlanContent(),
+      artifacts,
+      artifactDocuments
+    };
+  } catch (err) {
+    if (err instanceof CursorAgentError) {
+      if (resumed) {
+        clearSessionAgentId(workdir, ctx.sessionId, ctx.user);
+      }
+      throw new Error(
+        `Cursor \u542F\u52A8\u5931\u8D25: ${err.message}${err.isRetryable ? "\uFF08\u53EF\u91CD\u8BD5\uFF09" : ""}`
+      );
+    }
+    throw err;
+  } finally {
+    logAbortSignalStats(signal, "runCursorAgent:finally-before-cleanup");
+    signal?.removeEventListener("abort", abortRun);
+    logAbortSignalStats(signal, "runCursorAgent:finally-after-cleanup");
+    await agent[Symbol.asyncDispose]();
+  }
+}
+
+// src/commands/connect/webide-agent-registry.ts
+import { existsSync as existsSync3, mkdirSync as mkdirSync4, readFileSync as readFileSync4, writeFileSync as writeFileSync4 } from "node:fs";
+import { dirname as dirname3, resolve as resolve4 } from "node:path";
+function registryPath2(workdir, taskId) {
+  return resolve4(workdir, ".apm", "webide", taskId, "cursor-agent.json");
+}
+function readRegistry2(path) {
+  if (!existsSync3(path)) {
+    return {};
+  }
+  try {
+    const parsed = JSON.parse(readFileSync4(path, "utf8"));
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+      const agentId = parsed.agentId;
+      if (typeof agentId === "string" && agentId.trim()) {
+        return { agentId: agentId.trim() };
+      }
+    }
+  } catch {
+  }
+  return {};
+}
+function writeRegistry2(path, registry) {
+  mkdirSync4(dirname3(path), { recursive: true });
+  writeFileSync4(path, `${JSON.stringify(registry, null, 2)}
+`, "utf8");
+}
+function loadWebIdeAgentId(workdir, taskId) {
+  return readRegistry2(registryPath2(workdir, taskId)).agentId;
+}
+function saveWebIdeAgentId(workdir, taskId, agentId) {
+  writeRegistry2(registryPath2(workdir, taskId), { agentId });
+}
+function clearWebIdeAgentId(workdir, taskId) {
+  const path = registryPath2(workdir, taskId);
+  if (!existsSync3(path)) return;
+  writeRegistry2(path, {});
+}
+
+// src/commands/connect/webide-ask-question.ts
+import { setTimeout as delay } from "node:timers/promises";
+var POLL_INTERVAL_MS = 2e3;
+function asString(value) {
+  return typeof value === "string" ? value.trim() : "";
+}
+function parseQuestions(args) {
+  const title = asString(args.title) || void 0;
+  const raw = args.questions;
+  if (!Array.isArray(raw) || raw.length === 0) {
+    throw new Error("AskQuestion \u7F3A\u5C11 questions");
+  }
+  const questions = [];
+  for (const item of raw) {
+    if (!item || typeof item !== "object" || Array.isArray(item)) continue;
+    const row = item;
+    const id = asString(row.id);
+    const prompt = asString(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 = asString(o.id);
+      const label = asString(o.label);
+      if (oid && label) options.push({ id: oid, label });
+    }
+    if (options.length < 2) {
+      throw new Error(`AskQuestion \u95EE\u9898 ${id} \u81F3\u5C11\u9700\u8981 2 \u4E2A\u9009\u9879`);
+    }
+    questions.push({ id, prompt, options });
+  }
+  if (questions.length === 0) {
+    throw new Error("AskQuestion \u65E0\u6709\u6548\u95EE\u9898");
+  }
+  return { title, questions };
+}
+function createWebIdeAskQuestionExecute(options) {
+  const { cfg, taskId, signal } = options;
+  return async (args) => {
+    const parsed = parseQuestions(args);
+    const api = createApmApiClient(cfg);
+    console.log(
+      `[apm] AskQuestion \u521B\u5EFA\u5F85\u786E\u8BA4\u9879 taskId=${taskId} count=${parsed.questions.length}`
+    );
+    await api.cli.webideReplaceAssumptions({
+      taskId,
+      title: parsed.title,
+      questions: parsed.questions
+    });
+    while (true) {
+      if (signal?.aborted) {
+        throw new Error("AskQuestion \u5DF2\u53D6\u6D88");
+      }
+      const list = await api.cli.webideListAssumptions({ taskId });
+      const byId = new Map(
+        list.assumptions.map((a) => [a.questionId, a])
+      );
+      const pending = parsed.questions.filter((q) => {
+        const row = byId.get(q.id);
+        return !row || row.status !== "RESOLVED";
+      });
+      if (pending.length === 0) {
+        const answers = parsed.questions.map((q) => {
+          const row = byId.get(q.id);
+          return {
+            questionId: q.id,
+            prompt: q.prompt,
+            selectedOptionId: row.selectedOptionId,
+            customAnswer: row.customAnswer,
+            resolution: row.resolution
+          };
+        });
+        console.log(
+          `[apm] AskQuestion \u7528\u6237\u5DF2\u786E\u8BA4 taskId=${taskId} count=${answers.length}`
+        );
+        return JSON.stringify(
+          {
+            title: parsed.title,
+            answers
+          },
+          null,
+          2
+        );
+      }
+      await delay(POLL_INTERVAL_MS);
+    }
+  };
+}
+
+// src/commands/deploy/internal/minio.ts
+import * as Minio from "minio";
+var MinioClient = class {
+  inner;
+  constructor(opts) {
+    const endPoint = opts.endPoint.replace(/^https?:\/\//i, "").split("/")[0] ?? opts.endPoint;
+    this.inner = new Minio.Client({
+      endPoint,
+      port: opts.port,
+      useSSL: opts.useSSL,
+      accessKey: opts.accessKey,
+      secretKey: opts.secretKey
+    });
+  }
+  async ensureBucket(bucket) {
+    const exists = await this.inner.bucketExists(bucket);
+    if (!exists) {
+      await this.inner.makeBucket(bucket);
+    }
+  }
+  async deleteObjectsByPrefix(bucket, prefix) {
+    const objectsStream = this.inner.listObjectsV2(bucket, prefix, true);
+    const keys = [];
+    await new Promise((resolve5, reject) => {
+      objectsStream.on("data", (obj) => {
+        if (obj.name) {
+          keys.push(obj.name);
+        }
+      });
+      objectsStream.on("error", reject);
+      objectsStream.on("end", resolve5);
+    });
+    const chunkSize = 500;
+    for (let i = 0; i < keys.length; i += chunkSize) {
+      const chunk = keys.slice(i, i + chunkSize);
+      await this.inner.removeObjects(
+        bucket,
+        chunk.map((name) => name)
+      );
+    }
+  }
+  async putObject(bucket, objectKey, body, meta) {
+    await this.inner.putObject(bucket, objectKey, body, body.length, meta);
+  }
+  /** 匿名可读当前桶全部对象（便于静态站点直链） */
+  async setBucketPublicRead(bucket) {
+    const policy = {
+      Version: "2012-10-17",
+      Statement: [
+        {
+          Effect: "Allow",
+          Principal: { AWS: ["*"] },
+          Action: ["s3:GetObject"],
+          Resource: [`arn:aws:s3:::${bucket}/*`]
+        }
+      ]
+    };
+    await this.inner.setBucketPolicy(bucket, JSON.stringify(policy));
+  }
+};
+
+// src/commands/deploy/internal/deploy-artifact-minio.ts
+async function fetchDeployArtifactStorage(api) {
+  return api.cli.getDeployArtifactStorage(void 0);
+}
+
+// src/commands/connect/webide-message-log.ts
+var SYNC_INTERVAL_MS = 2e3;
+function webIdeEventsObjectPrefix(taskId, messageId) {
+  return `events/webide/${taskId}/${messageId}/`;
+}
+async function putDirtyEvents(minio, bucket, prefix, events) {
+  for (const event of events) {
+    const key = `${prefix}${event.index}.json`;
+    const body = Buffer.from(
+      JSON.stringify({
+        index: event.index,
+        type: event.type,
+        data: event.data
+      }),
+      "utf8"
+    );
+    await minio.putObject(bucket, key, body, {
+      "Content-Type": "application/json"
+    });
+  }
+}
+async function upsertLogHeader(cfg, ctx, patch) {
+  const api = createApmApiClient(cfg);
+  await api.cli.webideUpsertMessageLog({
+    messageId: ctx.messageId,
+    agentId: ctx.agentId,
+    objectPrefix: webIdeEventsObjectPrefix(ctx.taskId, ctx.messageId),
+    ...patch
+  });
+}
+function createThrottledWebIdeMessageLogSync(cfg, ctx, onError) {
+  let lastRunAt = 0;
+  let timer;
+  let latestSession;
+  let syncChain = Promise.resolve();
+  let minio;
+  let bucket = "";
+  const ensureMinio = async () => {
+    if (minio) return;
+    const storage = await fetchDeployArtifactStorage(createApmApiClient(cfg));
+    minio = new MinioClient({
+      endPoint: storage.endpoint,
+      port: storage.port,
+      useSSL: storage.useSsl,
+      accessKey: storage.accessKey,
+      secretKey: storage.secretKey
+    });
+    bucket = storage.bucket;
+    await minio.ensureBucket(bucket);
+  };
+  const syncDirtyEventsOnce = async (session) => {
+    const events = session.getDirtyEvents();
+    if (events.length === 0) return;
+    lastRunAt = Date.now();
+    try {
+      await ensureMinio();
+      const prefix = webIdeEventsObjectPrefix(ctx.taskId, ctx.messageId);
+      await putDirtyEvents(minio, bucket, prefix, events);
+      await upsertLogHeader(cfg, ctx, {
+        eventCount: session.getEventCount()
+      });
+      session.clearDirty(events.map((e) => e.index));
+    } catch (err) {
+      onError(err);
+    }
+  };
+  const drainDirtyEvents = async (session) => {
+    while (session.getDirtyEvents().length > 0) {
+      await syncDirtyEventsOnce(session);
+    }
+  };
+  const enqueueSync = (session) => {
+    syncChain = syncChain.then(() => drainDirtyEvents(session));
+  };
+  return {
+    async markRun(runId, runStatus, lastError) {
+      try {
+        await upsertLogHeader(cfg, ctx, {
+          runId,
+          runStatus,
+          lastError: lastError ?? null
+        });
+      } catch (err) {
+        onError(err);
+      }
+    },
+    schedule(session) {
+      latestSession = session;
+      const now = Date.now();
+      const elapsed = now - lastRunAt;
+      if (elapsed >= SYNC_INTERVAL_MS) {
+        if (timer) {
+          clearTimeout(timer);
+          timer = void 0;
+        }
+        enqueueSync(session);
+        return;
+      }
+      if (timer) return;
+      timer = setTimeout(() => {
+        timer = void 0;
+        if (latestSession) enqueueSync(latestSession);
+      }, SYNC_INTERVAL_MS - elapsed);
+    },
+    async flush(session) {
+      if (timer) {
+        clearTimeout(timer);
+        timer = void 0;
+      }
+      await syncChain;
+      await drainDirtyEvents(session);
+    }
+  };
+}
+
+// src/commands/connect/ensure-message-reply.ts
+var DEFAULT_REPLY = "\u4EFB\u52A1\u5DF2\u5B8C\u6210\u3002";
+function resolveMessageReplyFallback(fallback) {
+  for (const candidate of [
+    fallback.assistantText,
+    fallback.result,
+    fallback.createPlan
+  ]) {
+    const trimmed = candidate?.trim();
+    if (trimmed) {
+      return trimmed;
+    }
+  }
+  return DEFAULT_REPLY;
+}
+
+// src/commands/init.ts
+import { join as join5 } from "path";
+import { readFileSync as readFileSync6, writeFileSync as writeFileSync7 } from "fs";
+
+// src/deployment-config-sync.ts
+import { join as join3 } from "path";
+import { writeFileSync as writeFileSync5 } from "fs";
+
+// src/git-remote.ts
+import { execFile } from "child_process";
+import { promisify } from "util";
+var execFileAsync = promisify(execFile);
+async function tryReadGitOriginUrl(cwd) {
+  try {
+    const { stdout } = await execFileAsync(
+      "git",
+      ["config", "--get", "remote.origin.url"],
+      { cwd, encoding: "utf8", maxBuffer: 1024 * 1024 }
+    );
+    const url = stdout.trim();
+    return url || null;
+  } catch {
+    return null;
+  }
+}
+
+// src/git-utils.ts
+import { execFile as execFile2 } from "child_process";
+import { promisify as promisify2 } from "util";
+var execFileAsync2 = promisify2(execFile2);
+async function execGit(cwd, args, quiet = false) {
+  try {
+    const { stdout, stderr } = await execFileAsync2("git", args, {
+      cwd,
+      encoding: "utf8",
+      maxBuffer: 10 * 1024 * 1024
+    });
+    if (!quiet && stderr.trim()) {
+      process.stderr.write(stderr);
+    }
+    return stdout;
+  } catch (err) {
+    const e = err;
+    const detail = (e.stderr ?? e.message ?? String(err)).trim();
+    throw new Error(
+      `[apm] git ${args.join(" ")} \u5931\u8D25${detail ? `: ${detail}` : ""}`
+    );
+  }
+}
+async function isGitRepo(cwd) {
+  try {
+    await execGit(cwd, ["rev-parse", "--git-dir"], true);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function resolveGitRepoRoot(cwd) {
+  return (await execGit(cwd, ["rev-parse", "--show-toplevel"], true)).trim();
+}
+async function hasUpstream(cwd) {
+  try {
+    await execGit(cwd, ["rev-parse", "--abbrev-ref", "@{upstream}"], true);
+    return true;
+  } catch {
+    return false;
+  }
+}
+var GITIGNORE_COMMIT_MESSAGE = "chore(apm): ignore .apm directory";
+async function commitAndPushGitignore(workdir) {
+  if (!await isGitRepo(workdir)) {
+    console.log("[apm] \u5F53\u524D\u76EE\u5F55\u4E0D\u662F git \u4ED3\u5E93\uFF0C\u8BF7\u624B\u52A8\u63D0\u4EA4 .gitignore");
+    return;
+  }
+  await execGit(workdir, ["add", "--", ".gitignore"]);
+  await execGit(workdir, ["commit", "-m", GITIGNORE_COMMIT_MESSAGE]);
+  console.log(`[apm] \u5DF2\u63D0\u4EA4 .gitignore: ${GITIGNORE_COMMIT_MESSAGE}`);
+  const originUrl = await tryReadGitOriginUrl(workdir);
+  if (!originUrl) {
+    console.log("[apm] \u672A\u914D\u7F6E remote.origin\uFF0C\u8BF7\u7A0D\u540E\u624B\u52A8 push .gitignore");
+    return;
+  }
+  if (await hasUpstream(workdir)) {
+    await execGit(workdir, ["push"]);
+  } else {
+    await execGit(workdir, ["push", "-u", "origin", "HEAD"]);
+  }
+  console.log("[apm] \u5DF2\u63A8\u9001 .gitignore");
+}
+
+// src/baseline-resolve.ts
+function formatBaselineDiagnostic(workdirPath, baselineWorkdirPath, diagnostic) {
+  return diagnostic?.message ?? `\u672A\u5728\u5E73\u53F0\u627E\u5230\u4E0E\u5F53\u524D\u76EE\u5F55\u5339\u914D\u7684\u5DE5\u4F5C\u76EE\u5F55\u767B\u8BB0\uFF1A${workdirPath}\uFF08\u89C4\u8303\u5316\uFF1A${baselineWorkdirPath}\uFF09
+\u8BF7\u5148\u5728\u5E73\u53F0\u767B\u8BB0\u8BE5\u8DEF\u5F84\u5BF9\u5E94\u7684\u5DE5\u4F5C\u76EE\u5F55\u4E0E\u4ED3\u5E93\u3002`;
+}
+async function matchRepositoryByGitRemote(api, workdirPath) {
+  const gitRoot = await resolveGitRepoRoot(workdirPath);
+  const gitUrl = await tryReadGitOriginUrl(gitRoot);
+  if (!gitUrl) {
+    return null;
+  }
+  const matched = await api.cli.matchRepository({ url: gitUrl });
+  const repositoryId = matched.repositoryId?.trim();
+  const defaultBranch = matched.defaultBranch?.trim();
+  if (!repositoryId || !defaultBranch) {
+    return null;
+  }
+  console.log(
+    `[apm] \u5DE5\u4F5C\u7A7A\u95F4\u8DEF\u5F84\u672A\u5339\u914D\uFF0C\u5DF2\u901A\u8FC7 git remote \u5173\u8054\u4ED3\u5E93: ${gitUrl}`
+  );
+  return { repositoryId, defaultBranch };
+}
+async function resolveWorkspaceBaseline(api, workdirPath) {
+  const baseline = await api.cli.workspaceBaseline({ workdirPath });
+  const repositoryId = baseline.repositoryId?.trim();
+  const defaultBranch = baseline.defaultBranch?.trim();
+  if (repositoryId && defaultBranch) {
+    return {
+      repositoryId,
+      defaultBranch,
+      workdirPath: baseline.workdirPath,
+      matchedViaGitRemote: false
+    };
+  }
+  const viaGit = await matchRepositoryByGitRemote(api, workdirPath);
+  if (viaGit) {
+    return {
+      ...viaGit,
+      workdirPath: baseline.workdirPath,
+      matchedViaGitRemote: true
+    };
+  }
+  throw new Error(
+    `[apm] ${formatBaselineDiagnostic(
+      workdirPath,
+      baseline.workdirPath,
+      baseline.diagnostic
+    )}`
+  );
+}
+
+// src/deployment-config-sync.ts
+var TEMPLATE_HINT = "\u4FDD\u7559\u6A21\u677F .apm/apm.config.json";
+var SYNC_HINT = "\u767B\u8BB0\u5DE5\u4F5C\u7A7A\u95F4\u8DEF\u5F84\u3001\u7ED1\u5B9A\u4ED3\u5E93\u540E\uFF0C\u53EF\u6267\u884C: apm sync-deploy-config";
+async function resolveRepositoryIdForSync(api, workdirPath) {
+  try {
+    const baseline = await resolveWorkspaceBaseline(api, workdirPath);
+    return { repositoryId: baseline.repositoryId, diagnostic: null };
+  } catch (err) {
+    const detail = err instanceof Error ? err.message : String(err);
+    return {
+      repositoryId: null,
+      diagnostic: detail.replace(/^\[apm\]\s*/, "")
+    };
+  }
+}
+async function syncRemoteDeploymentConfig(workdirPath, apmDir) {
+  const cfg = await tryReadApmConfig();
+  if (!cfg || !resolveApiKey(cfg)) {
+    console.log(
+      `[apm] \u672A\u68C0\u6D4B\u5230\u767B\u5F55\u4FE1\u606F\uFF0C\u8DF3\u8FC7\u5E73\u53F0\u90E8\u7F72\u914D\u7F6E\u540C\u6B65\uFF08${TEMPLATE_HINT}\uFF09\u3002
+[apm] \u8BF7\u5148\u6267\u884C apm login\uFF0C\u518D\u6267\u884C apm sync-deploy-config \u62C9\u53D6\u6700\u65B0\u914D\u7F6E\u3002`
+    );
+    return { synced: false, repositoryId: null };
+  }
+  const api = createApmApiClient(cfg);
+  const { repositoryId, diagnostic } = await resolveRepositoryIdForSync(
+    api,
+    workdirPath
+  );
+  if (!repositoryId) {
+    console.log(
+      `[apm] \u672A\u80FD\u540C\u6B65\u5E73\u53F0\u90E8\u7F72\u914D\u7F6E\uFF08${TEMPLATE_HINT}\uFF09\u3002
+${diagnostic ?? ""}
+[apm] ${SYNC_HINT}`
+    );
+    return { synced: false, repositoryId: null };
+  }
+  const { config } = await api.cli.getDeploymentConfiguration({ repositoryId });
+  if (!config) {
+    console.log(
+      `[apm] \u672A\u627E\u5230\u5173\u8054\u4ED3\u5E93\u7684\u90E8\u7F72\u914D\u7F6E\uFF08${TEMPLATE_HINT}\uFF0CrepositoryId\uFF1A${repositoryId}\uFF09\u3002
+[apm] \u8BF7\u5728\u5E73\u53F0\u300C\u90E8\u7F72\u914D\u7F6E\u300D\u4E2D\u521B\u5EFA\u914D\u7F6E\u5E76\u5173\u8054\u8BE5\u4ED3\u5E93\uFF0C\u7136\u540E\u6267\u884C: apm sync-deploy-config`
+    );
+    return { synced: false, repositoryId };
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(config.content);
+  } catch {
+    console.warn(
+      `[apm] \u8FDC\u7A0B\u90E8\u7F72\u914D\u7F6E\u300C${config.name}\u300DJSON \u65E0\u6548\uFF08${TEMPLATE_HINT}\uFF09`
+    );
+    return { synced: false, repositoryId };
+  }
+  const targetApmDir = apmDir ?? workspaceApmDir(workdirPath);
+  const apmConfigPath = toFsPath(join3(targetApmDir, "apm.config.json"));
+  writeFileSync5(apmConfigPath, `${JSON.stringify(parsed, null, 2)}
+`, "utf8");
+  console.log(`[apm] \u5DF2\u540C\u6B65\u5E73\u53F0\u90E8\u7F72\u914D\u7F6E: ${config.name}`);
+  console.log("[apm] \u5DF2\u5199\u5165 .apm/apm.config.json");
+  return { synced: true, repositoryId, configName: config.name };
+}
+
+// src/repository-project-documents-sync.ts
+import {
+  existsSync as existsSync4,
+  readdirSync as readdirSync2,
+  readFileSync as readFileSync5,
+  rmSync,
+  writeFileSync as writeFileSync6
+} from "fs";
+import { dirname as dirname4, join as join4, relative, sep } from "path";
+var MANIFEST_FILE = "manifest.json";
+function projectDocumentsDir(apmRoot) {
+  return join4(apmRoot ?? workspaceApmDir(), "project");
+}
+function projectDocumentLocalPath(apmRoot, documentPath) {
+  const normalized = normalizeLocalDocumentPath(documentPath);
+  return join4(projectDocumentsDir(apmRoot), ...normalized.split("/"));
+}
+function normalizeLocalDocumentPath(path) {
+  const trimmed = path.trim().replace(/\\/g, "/");
+  if (!trimmed || trimmed.startsWith("/") || /^[a-zA-Z]:/.test(trimmed)) {
+    throw new Error(`\u975E\u6CD5\u6587\u6863\u8DEF\u5F84: ${path}`);
+  }
+  const segments = trimmed.split("/").filter(Boolean);
+  if (segments.some((segment) => segment === ".." || segment === ".")) {
+    throw new Error(`\u975E\u6CD5\u6587\u6863\u8DEF\u5F84: ${path}`);
+  }
+  return segments.join("/");
+}
+function readLocalManifest(apmRoot) {
+  const manifestPath = join4(projectDocumentsDir(apmRoot), MANIFEST_FILE);
+  if (!existsSync4(manifestPath)) {
+    return null;
+  }
+  try {
+    return JSON.parse(
+      readFileSync5(manifestPath, "utf8")
+    );
+  } catch {
+    return null;
+  }
+}
+function diffManifestPaths(remote, local) {
+  const remoteMap = new Map(
+    (remote?.documents ?? []).map((doc) => [doc.path, doc.contentHash])
+  );
+  const localMap = new Map(
+    (local?.documents ?? []).map((doc) => [doc.path, doc.contentHash])
+  );
+  const download = [];
+  for (const [path, hash] of remoteMap) {
+    if (localMap.get(path) !== hash) {
+      download.push(path);
+    }
+  }
+  const deleteLocal = [];
+  for (const path of localMap.keys()) {
+    if (!remoteMap.has(path)) {
+      deleteLocal.push(path);
+    }
+  }
+  return { download, deleteLocal };
+}
+async function syncRepositoryProjectDocumentsPull(workdirPath, apmDir) {
+  const empty = {
+    synced: false,
+    repositoryId: null,
+    downloaded: 0,
+    deleted: 0
+  };
+  const cfg = await tryReadApmConfig();
+  if (!cfg || !resolveApiKey(cfg)) {
+    console.log(
+      "[apm] \u672A\u68C0\u6D4B\u5230\u767B\u5F55\u4FE1\u606F\uFF0C\u8DF3\u8FC7\u4ED3\u5E93\u9879\u76EE\u6587\u6863\u540C\u6B65\u3002\n[apm] \u8BF7\u5148\u6267\u884C apm login\u3002"
+    );
+    return empty;
+  }
+  const api = createApmApiClient(cfg);
+  const { repositoryId, diagnostic } = await resolveRepositoryIdForSync(
+    api,
+    workdirPath
+  );
+  if (!repositoryId) {
+    console.log(
+      `[apm] \u672A\u80FD\u540C\u6B65\u4ED3\u5E93\u9879\u76EE\u6587\u6863\u3002
+${diagnostic ?? ""}`
+    );
+    return empty;
+  }
+  const targetApmDir = apmDir ?? workspaceApmDir(workdirPath);
+  const projectDir = projectDocumentsDir(targetApmDir);
+  await ensureDirExists(projectDir);
+  const { manifest: remoteManifest } = await api.cli.getRepositoryProjectDocumentManifest({ repositoryId });
+  if (!remoteManifest) {
+    console.log(
+      `[apm] \u4ED3\u5E93 ${repositoryId} \u65E0\u9879\u76EE\u6587\u6863 manifest\uFF0C\u8DF3\u8FC7\u540C\u6B65\u3002`
+    );
+    return { ...empty, repositoryId };
+  }
+  const localManifest = readLocalManifest(targetApmDir);
+  const { download, deleteLocal } = diffManifestPaths(
+    remoteManifest,
+    localManifest
+  );
+  let downloaded = 0;
+  if (download.length > 0) {
+    const { list } = await api.cli.listRepositoryProjectDocuments({
+      repositoryId,
+      paths: download.join(",")
+    });
+    for (const doc of list) {
+      const absPath = toFsPath(projectDocumentLocalPath(targetApmDir, doc.path));
+      await ensureDirExists(dirname4(absPath));
+      writeFileSync6(absPath, doc.content, "utf8");
+      downloaded += 1;
+    }
+  }
+  let deleted = 0;
+  for (const path of deleteLocal) {
+    const absPath = toFsPath(projectDocumentLocalPath(targetApmDir, path));
+    if (existsSync4(absPath)) {
+      rmSync(absPath, { force: true });
+      deleted += 1;
+    }
+  }
+  writeFileSync6(
+    toFsPath(join4(projectDir, MANIFEST_FILE)),
+    `${JSON.stringify(remoteManifest, null, 2)}
+`,
+    "utf8"
+  );
+  console.log(
+    `[apm] \u5DF2\u540C\u6B65\u4ED3\u5E93\u9879\u76EE\u6587\u6863: \u4E0B\u8F7D ${downloaded}\uFF0C\u5220\u9664\u672C\u5730 ${deleted}`
+  );
+  return {
+    synced: true,
+    repositoryId,
+    downloaded,
+    deleted
+  };
+}
+
+// src/commands/init.ts
+async function ensureWorkspaceInitialized(workdir, options) {
+  if (isWorkspaceApmInitialized(workdir)) {
+    return { didInit: false };
+  }
+  console.log(
+    `[apm] \u5DE5\u4F5C\u76EE\u5F55 ${workdir} \u672A\u68C0\u6D4B\u5230\u5DF2\u521D\u59CB\u5316\u7684 .apm\uFF0C\u6B63\u5728\u81EA\u52A8\u521D\u59CB\u5316\u2026`
+  );
+  await ensureWorkspaceApmDirForInit(workdir);
+  if (ensureApmGitignoredInRepo(workdir)) {
+    console.log("[apm] \u5DF2\u5728 .gitignore \u4E2D\u6DFB\u52A0 **/.apm/**");
+    await commitAndPushGitignore(workdir);
+  }
+  const apmDir = workspaceApmDir(workdir);
+  await copyTemplateFiles(apmDir, workdir);
+  const syncResult = await syncRemoteDeploymentConfig(workdir, apmDir);
+  await syncRepositoryProjectDocumentsPull(workdir, apmDir);
+  const trimmedName = options?.name?.trim();
+  if (trimmedName) {
+    const apmConfigPath = toFsPath(join5(apmDir, "apm.config.json"));
+    const config = readFileSync6(apmConfigPath, "utf8");
+    const configJson = JSON.parse(config);
+    configJson.name = trimmedName;
+    writeFileSync7(
+      apmConfigPath,
+      `${JSON.stringify(configJson, null, 2)}
+`,
+      "utf8"
+    );
+  }
+  console.log(`[apm] \u5DF2\u521D\u59CB\u5316\u5DE5\u4F5C\u533A\uFF1A${apmDir}`);
+  return { didInit: true, syncResult };
+}
+
+// src/commands/connect/handle-webide-message.ts
+async function updateStatus(cfg, messageId, status) {
+  const api = createApmApiClient(cfg);
+  await api.cli.webideUpdateMessageStatus({ id: messageId, status });
+}
+async function setError(cfg, messageId, error) {
+  const api = createApmApiClient(cfg);
+  await api.cli.webideSetMessageError({ id: messageId, error });
+}
+async function appendContent(cfg, messageId, content) {
+  const api = createApmApiClient(cfg);
+  await api.cli.webideAppendMessageContent({ id: messageId, content });
+}
+async function handleWebIdeInboundMessage(cfg, msg, signal) {
+  const workdir = requireRemoteWorkdir(msg.workdir);
+  const messageId = msg.messageId;
+  const taskId = msg.taskId;
+  console.log(
+    `[apm] webide-message action=${msg.action} taskId=${taskId} messageId=${messageId}`
+  );
+  await updateStatus(cfg, messageId, "TYPING");
+  try {
+    if (signal.aborted) throw new Error("\u4EFB\u52A1\u5DF2\u53D6\u6D88");
+    const { didInit } = await ensureWorkspaceInitialized(workdir);
+    if (!didInit) {
+      assertApmGitignoredInRepo(workdir);
+    }
+    const savedAgentId = loadWebIdeAgentId(workdir, taskId);
+    const logSyncRef = { current: null };
+    const outcome = await runCursorAgent(
+      cfg,
+      {
+        messageId,
+        sessionId: `webide:${taskId}`,
+        prompt: msg.content,
+        model: msg.model,
+        apiKey: msg.apiKey,
+        workdir,
+        user: msg.user || "webide",
+        resumeAgentId: savedAgentId
+      },
+      {
+        signal,
+        appendMessageContent: (content) => appendContent(cfg, messageId, content),
+        askQuestionExecute: createWebIdeAskQuestionExecute({
+          cfg,
+          taskId,
+          signal
+        }),
+        createRemoteLogSync: (agentId) => {
+          saveWebIdeAgentId(workdir, taskId, agentId);
+          logSyncRef.current = createThrottledWebIdeMessageLogSync(
+            cfg,
+            { taskId, messageId, agentId },
+            (err) => {
+              console.warn(
+                "[apm] WebIDE \u65E5\u5FD7\u540C\u6B65\u5931\u8D25:",
+                err instanceof Error ? err.message : err
+              );
+            }
+          );
+          return logSyncRef.current;
+        },
+        onRunStarted: async ({ agentId, runId }) => {
+          saveWebIdeAgentId(workdir, taskId, agentId);
+          await logSyncRef.current?.markRun(runId, "running");
+        }
+      }
+    );
+    saveWebIdeAgentId(workdir, taskId, outcome.agentId);
+    if (outcome.status === "error") {
+      const detail = formatCursorRunFailure(outcome.runId, {
+        resultText: outcome.result
+      });
+      await logSyncRef.current?.markRun(outcome.runId, "error", detail);
+      await setError(cfg, messageId, detail);
+      return;
+    }
+    if (outcome.status === "cancelled" || signal.aborted) {
+      await logSyncRef.current?.markRun(outcome.runId, "cancelled", "\u5DF2\u53D6\u6D88");
+      await updateStatus(cfg, messageId, "CANCELLED");
+      return;
+    }
+    const fallback = resolveMessageReplyFallback({
+      assistantText: outcome.assistantText,
+      result: outcome.result,
+      createPlan: outcome.createPlan
+    });
+    const api = createApmApiClient(cfg);
+    await api.cli.webideEnsureMessageContent({
+      id: messageId,
+      content: fallback
+    });
+    await logSyncRef.current?.markRun(outcome.runId, "finished");
+    await updateStatus(cfg, messageId, "SUCCESS");
+    console.log(
+      `[apm] webide-message \u5B8C\u6210 action=${msg.action} messageId=${messageId} agentId=${outcome.agentId}`
+    );
+  } catch (err) {
+    const detail = err instanceof Error ? err.message : String(err);
+    console.error(`[apm] webide-message \u5931\u8D25: ${detail}`);
+    if (detail.includes("\u590D\u7528 Agent") || detail.includes("resume")) {
+      clearWebIdeAgentId(workdir, taskId);
+    }
+    try {
+      await setError(cfg, messageId, detail);
+    } catch (statusErr) {
+      console.error(
+        "[apm] \u5199\u5165 WebIDE 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) {
+  const controller = new AbortController();
+  controllers.set(msg.messageId, controller);
+  try {
+    await handleWebIdeInboundMessage(cfg, msg, controller.signal);
+    parentPort?.postMessage({
+      type: "done",
+      messageId: msg.messageId
+    });
+  } catch (err) {
+    parentPort?.postMessage({
+      type: "error",
+      messageId: msg.messageId,
+      error: err instanceof Error ? err.message : String(err)
+    });
+  } finally {
+    controllers.delete(msg.messageId);
+  }
+}
+parentPort?.on("message", (raw) => {
+  if (raw.type === "cancel") {
+    controllers.get(raw.messageId)?.abort();
+    return;
+  }
+  if (raw.type === "run") {
+    void runJob(raw.cfg, raw.msg);
+  }
+});
+var boot = workerData;
+if (boot?.cfg && boot?.msg) {
+  void runJob(boot.cfg, boot.msg);
+}