ai-project-manage-cli 7.1.11 → 7.1.13

package/dist/index.js

@@ -1,15 +1,23 @@
 #!/usr/bin/env node
-
-// src/index.ts
-import { Command } from "commander";
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res, err) => function __init() {
+  if (err) throw err[0];
+  try {
+    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+  } catch (e) {
+    throw err = [e], e;
+  }
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
 
 // 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");
-var DEFAULT_BASE_URL = "http://127.0.0.1:3000";
 function resolveClientMachineId(cfg) {
   return (cfg.clientMachineId ?? cfg.userId ?? "").trim();
 }
@@ -78,12 +86,995 @@ function buildAgentWsUrl(httpBase, apiKey) {
   const q = new URLSearchParams({ apiKey });
   return `${origin}/ws/agent?${q.toString()}`;
 }
+var APM_CONFIG_DIR, APM_CONFIG_PATH, DEFAULT_BASE_URL;
+var init_config = __esm({
+  "src/config.ts"() {
+    "use strict";
+    APM_CONFIG_DIR = join(homedir(), ".config", "apm");
+    APM_CONFIG_PATH = join(APM_CONFIG_DIR, "config.json");
+    DEFAULT_BASE_URL = "http://127.0.0.1:3000";
+  }
+});
+
+// src/api/request-config.ts
+import { defineEndpoint } from "listpage-http";
+var requestConfig;
+var init_request_config = __esm({
+  "src/api/request-config.ts"() {
+    "use strict";
+    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"
+        }),
+        webideRecommendPlan: defineEndpoint({
+          method: "PUT",
+          path: "/cli/webide/plan-recommendation"
+        }),
+        webideUpsertPlan: defineEndpoint({
+          method: "PUT",
+          path: "/cli/webide/plan"
+        }),
+        webideReplaceTestCases: defineEndpoint({
+          method: "PUT",
+          path: "/cli/webide/test-cases"
+        }),
+        webideListTerminals: defineEndpoint({
+          method: "GET",
+          path: "/cli/webide/terminals"
+        }),
+        webideUpsertTerminal: defineEndpoint({
+          method: "POST",
+          path: "/cli/webide/terminals"
+        }),
+        webideUpdateTerminalStatus: defineEndpoint({
+          method: "PUT",
+          path: "/cli/webide/terminals/status"
+        }),
+        webideUpdateTerminalMeta: defineEndpoint({
+          method: "PUT",
+          path: "/cli/webide/terminals/meta"
+        }),
+        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"
+        }),
+        createWebIdeDraftPullRequest: defineEndpoint({
+          method: "POST",
+          path: "/cli/webide/draft-pull-requests"
+        }),
+        webideMergePullRequests: defineEndpoint({
+          method: "POST",
+          path: "/cli/webide/pull-requests/merge"
+        }),
+        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/api/client.ts
+import { createApiClient } from "listpage-http";
+function createApmApiClient(cfg) {
+  const baseURL = `${cfg.baseUrl.trim().replace(/\/+$/, "")}/api/v1`;
+  return createApiClient(requestConfig, {
+    baseURL,
+    getToken: () => resolveApiKey(cfg) || void 0,
+    successCodes: [0],
+    unauthorizedCodes: [401]
+  });
+}
+var init_client = __esm({
+  "src/api/client.ts"() {
+    "use strict";
+    init_request_config();
+    init_config();
+  }
+});
+
+// src/commands/deploy/internal/minio.ts
+import { statSync as statSync5 } from "node:fs";
+import { readdir, readFile } from "node:fs/promises";
+import path from "node:path";
+import * as Minio from "minio";
+async function isDirectoryPath(dir) {
+  try {
+    const st = statSync5(dir);
+    return st.isDirectory();
+  } catch {
+    return false;
+  }
+}
+function sanitizeRelativePath(rel) {
+  const norm = rel.replace(/\\/g, "/").replace(/^\/+/, "");
+  const segments = norm.split("/").filter(Boolean);
+  for (const s of segments) {
+    if (s === "." || s === "..") {
+      throw new Error(`\u975E\u6CD5\u76F8\u5BF9\u8DEF\u5F84\u7247\u6BB5\uFF1A${s}`);
+    }
+  }
+  return segments.join("/");
+}
+async function collectFiles(root) {
+  const out = [];
+  async function walk(dir, prefix) {
+    const entries = await readdir(dir, { withFileTypes: true });
+    for (const e of entries) {
+      const name = e.name;
+      if (name === "." || name === "..") {
+        continue;
+      }
+      const abs = path.join(dir, name);
+      const rel = prefix ? `${prefix}/${name}` : name;
+      if (e.isDirectory()) {
+        await walk(abs, rel);
+      } else if (e.isFile()) {
+        const st = statSync5(abs);
+        out.push({
+          absPath: abs,
+          relativePath: rel.replace(/\\/g, "/"),
+          size: st.size
+        });
+      }
+    }
+  }
+  await walk(root, "");
+  out.sort((a, b) => a.relativePath.localeCompare(b.relativePath));
+  return out;
+}
+async function readArtifactFile(absPath) {
+  return readFile(absPath);
+}
+function toMB(bytes) {
+  return Math.round(bytes / (1024 * 1024) * 1e3) / 1e3;
+}
+function detectMimeType(filePath) {
+  const ext = path.extname(filePath).toLowerCase();
+  return MIME[ext] ?? "";
+}
+var DEFAULT_MAX_FILE_SIZE_MB, MIME, MinioClient;
+var init_minio = __esm({
+  "src/commands/deploy/internal/minio.ts"() {
+    "use strict";
+    DEFAULT_MAX_FILE_SIZE_MB = 50;
+    MIME = {
+      ".html": "text/html; charset=utf-8",
+      ".css": "text/css; charset=utf-8",
+      ".js": "application/javascript; charset=utf-8",
+      ".json": "application/json; charset=utf-8",
+      ".svg": "image/svg+xml",
+      ".png": "image/png",
+      ".jpg": "image/jpeg",
+      ".jpeg": "image/jpeg",
+      ".gif": "image/gif",
+      ".webp": "image/webp",
+      ".woff": "font/woff",
+      ".woff2": "font/woff2",
+      ".ttf": "font/ttf",
+      ".ico": "image/x-icon",
+      ".txt": "text/plain; charset=utf-8",
+      ".map": "application/json"
+    };
+    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((resolve7, reject) => {
+          objectsStream.on("data", (obj) => {
+            if (obj.name) {
+              keys.push(obj.name);
+            }
+          });
+          objectsStream.on("error", reject);
+          objectsStream.on("end", resolve7);
+        });
+        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
+import { readFile as readFile2 } from "node:fs/promises";
+function formatDeployArtifactTimestamp(date = /* @__PURE__ */ new Date()) {
+  const pad2 = (n) => String(n).padStart(2, "0");
+  return `${date.getFullYear()}${pad2(date.getMonth() + 1)}${pad2(date.getDate())}${pad2(date.getHours())}${pad2(date.getMinutes())}${pad2(date.getSeconds())}`;
+}
+function sanitizeDeployProjectName(name) {
+  const trimmed = name.trim().replace(/\\/g, "/");
+  const base = trimmed.split("/").filter(Boolean).pop() ?? trimmed;
+  try {
+    return sanitizeRelativePath(base.replace(/[/\\:*?"<>|]/g, "_"));
+  } catch {
+    return "project";
+  }
+}
+function buildDeployArtifactFileName(kind, projectName, timestamp = formatDeployArtifactTimestamp()) {
+  const safeName = sanitizeDeployProjectName(projectName);
+  const suffix = kind === "frontend" ? "dist.zip" : "jar.zip";
+  return `${timestamp}-${safeName}.${suffix}`;
+}
+function buildDeployArtifactObjectKey(projectName, fileName) {
+  const safeProject = sanitizeDeployProjectName(projectName);
+  return `deploy/${safeProject}/${fileName}`;
+}
+function resolveDeploymentRunIdFromEnv() {
+  const raw = process.env[APM_DEPLOYMENT_RUN_ID_ENV]?.trim();
+  return raw || null;
+}
+async function fetchDeployArtifactStorage(api) {
+  return api.cli.getDeployArtifactStorage(void 0);
+}
+async function uploadDeployArtifactZip(options) {
+  const deploymentRunId = options.deploymentRunId ?? resolveDeploymentRunIdFromEnv();
+  if (!deploymentRunId && !options.uploadWithoutRunId) {
+    return null;
+  }
+  const cfg = await tryReadApmConfig();
+  if (!cfg || !resolveApiKey(cfg)) {
+    console.warn("[apm] \u672A\u767B\u5F55\uFF0C\u8DF3\u8FC7 MinIO \u90E8\u7F72\u4EA7\u7269\u5F52\u6863");
+    return null;
+  }
+  const api = options.api ?? createApmApiClient(cfg);
+  let storage;
+  try {
+    storage = await fetchDeployArtifactStorage(api);
+  } catch (error) {
+    const detail = error instanceof Error ? error.message : String(error);
+    console.warn(`[apm] \u83B7\u53D6 MinIO \u914D\u7F6E\u5931\u8D25\uFF0C\u8DF3\u8FC7\u90E8\u7F72\u4EA7\u7269\u5F52\u6863: ${detail}`);
+    return null;
+  }
+  const fileName = buildDeployArtifactFileName(
+    options.kind,
+    options.projectName,
+    options.timestamp
+  );
+  const objectKey = buildDeployArtifactObjectKey(options.projectName, fileName);
+  let body;
+  try {
+    body = await readFile2(options.zipPath);
+  } catch (error) {
+    const detail = error instanceof Error ? error.message : String(error);
+    console.warn(`[apm] \u8BFB\u53D6\u90E8\u7F72\u4EA7\u7269 zip \u5931\u8D25\uFF0C\u8DF3\u8FC7 MinIO \u5F52\u6863: ${detail}`);
+    return null;
+  }
+  try {
+    const client = new MinioClient({
+      endPoint: storage.endpoint,
+      port: storage.port,
+      useSSL: storage.useSsl,
+      accessKey: storage.accessKey,
+      secretKey: storage.secretKey
+    });
+    await client.ensureBucket(storage.bucket);
+    await client.putObject(storage.bucket, objectKey, body, {
+      "Content-Type": "application/zip"
+    });
+    console.error(
+      `[apm] \u672C\u5730\u76F4\u4F20 MinIO\uFF08\u4E0D\u7ECF\u5E73\u53F0\u670D\u52A1\u5668\uFF09: ${storage.endpoint}:${storage.port}/${storage.bucket}/${objectKey} (${(body.length / 1024 / 1024).toFixed(
+        2
+      )} MB)`
+    );
+  } catch (error) {
+    const detail = error instanceof Error ? error.message : String(error);
+    console.warn(`[apm] MinIO \u90E8\u7F72\u4EA7\u7269\u5F52\u6863\u5931\u8D25: ${detail}`);
+    return null;
+  }
+  if (deploymentRunId) {
+    try {
+      await api.cli.attachTaskDeploymentArtifact({
+        id: deploymentRunId,
+        artifactObjectKey: objectKey,
+        artifactFileName: fileName
+      });
+      console.error(
+        `[apm] \u5DF2\u7ED1\u5B9A\u90E8\u7F72\u4EA7\u7269\u5230\u8BB0\u5F55 id=${deploymentRunId} file=${fileName}`
+      );
+    } catch (error) {
+      const detail = error instanceof Error ? error.message : String(error);
+      console.warn(`[apm] \u7ED1\u5B9A\u90E8\u7F72\u4EA7\u7269\u5230\u8BB0\u5F55\u5931\u8D25: ${detail}`);
+      return null;
+    }
+  }
+  return {
+    objectKey,
+    fileName,
+    bucket: storage.bucket
+  };
+}
+var APM_DEPLOYMENT_RUN_ID_ENV;
+var init_deploy_artifact_minio = __esm({
+  "src/commands/deploy/internal/deploy-artifact-minio.ts"() {
+    "use strict";
+    init_client();
+    init_config();
+    init_minio();
+    init_minio();
+    APM_DEPLOYMENT_RUN_ID_ENV = "APM_DEPLOYMENT_RUN_ID";
+  }
+});
+
+// src/commands/connect/webide-terminal-registry.ts
+var webide_terminal_registry_exports = {};
+__export(webide_terminal_registry_exports, {
+  WEBIDE_TERMINAL_LINES_PER_CHUNK: () => WEBIDE_TERMINAL_LINES_PER_CHUNK,
+  WebIdeTerminalRegistry: () => WebIdeTerminalRegistry,
+  getWebIdeTerminalRegistry: () => getWebIdeTerminalRegistry
+});
+import { spawn } from "node:child_process";
+import { execFile as execFile3 } from "node:child_process";
+import { promisify as promisify3 } from "node:util";
+function taskKey(taskId, key) {
+  return `${taskId}\0${key}`;
+}
+function chunkKey(prefix, chunkIndex) {
+  return `${prefix}chunks/${String(chunkIndex).padStart(6, "0")}.json`;
+}
+function extractPortsAndUrl(text) {
+  const ports = /* @__PURE__ */ new Set();
+  let primaryUrl = null;
+  let m;
+  const re = new RegExp(PORT_URL_RE.source, "gi");
+  while ((m = re.exec(text)) !== null) {
+    const urlCandidate = m[2];
+    if (urlCandidate) {
+      primaryUrl = primaryUrl ?? urlCandidate.replace(/[),.;]+$/, "");
+      try {
+        const u = new URL(primaryUrl);
+        if (u.port) ports.add(Number(u.port));
+        else if (u.protocol === "https:") ports.add(443);
+        else ports.add(80);
+      } catch {
+      }
+    }
+    for (const g of [m[1], m[3], m[4]]) {
+      if (g) {
+        const p = Number(g);
+        if (p > 0 && p < 65536) ports.add(p);
+      }
+    }
+  }
+  const httpMatch = text.match(/https?:\/\/[^\s)'"]+/i);
+  if (httpMatch && !primaryUrl) {
+    primaryUrl = httpMatch[0].replace(/[),.;]+$/, "");
+  }
+  return { ports: [...ports].sort((a, b) => a - b), primaryUrl };
+}
+function killProcessTree(pid) {
+  try {
+    process.kill(-pid, "SIGTERM");
+  } catch {
+    try {
+      process.kill(pid, "SIGTERM");
+    } catch {
+    }
+  }
+}
+function forceKillProcessTree(pid) {
+  try {
+    process.kill(-pid, "SIGKILL");
+  } catch {
+    try {
+      process.kill(pid, "SIGKILL");
+    } catch {
+    }
+  }
+}
+async function probeListenPorts(pid) {
+  try {
+    const { stdout } = await execFileAsync3(
+      "lsof",
+      ["-nP", `-p${pid}`, "-iTCP", "-sTCP:LISTEN"],
+      { timeout: 3e3, maxBuffer: 1024 * 1024 }
+    );
+    const ports = /* @__PURE__ */ new Set();
+    for (const line of stdout.split("\n")) {
+      const m = line.match(/:(\d+)\s+\(LISTEN\)/);
+      if (m) {
+        const p = Number(m[1]);
+        if (p > 0 && p < 65536) ports.add(p);
+      }
+    }
+    return [...ports].sort((a, b) => a - b);
+  } catch {
+    return [];
+  }
+}
+function getWebIdeTerminalRegistry(cfg) {
+  if (!registrySingleton) {
+    registrySingleton = new WebIdeTerminalRegistry(cfg);
+  }
+  return registrySingleton;
+}
+var execFileAsync3, WEBIDE_TERMINAL_LINES_PER_CHUNK, SYNC_INTERVAL_MS, PORT_PROBE_INTERVAL_MS, STOP_SIGKILL_MS, PORT_URL_RE, WebIdeTerminalRegistry, registrySingleton;
+var init_webide_terminal_registry = __esm({
+  "src/commands/connect/webide-terminal-registry.ts"() {
+    "use strict";
+    init_client();
+    init_deploy_artifact_minio();
+    init_minio();
+    execFileAsync3 = promisify3(execFile3);
+    WEBIDE_TERMINAL_LINES_PER_CHUNK = 50;
+    SYNC_INTERVAL_MS = 400;
+    PORT_PROBE_INTERVAL_MS = 2e3;
+    STOP_SIGKILL_MS = 5e3;
+    PORT_URL_RE = /(?:https?:\/\/(?:localhost|127\.0\.0\.1|0\.0\.0\.0)(?::(\d+))?|(?:Local|Network):\s*(https?:\/\/\S+)|listening\s+(?:on\s+)?(?:port\s+)?(\d+)|(?:port|PORT)\s*[:=]\s*(\d+))/gi;
+    WebIdeTerminalRegistry = class {
+      constructor(cfg) {
+        this.cfg = cfg;
+      }
+      cfg;
+      byId = /* @__PURE__ */ new Map();
+      byTaskKey = /* @__PURE__ */ new Map();
+      minio;
+      bucket = "";
+      async ensureMinio() {
+        if (this.minio) return;
+        const storage = await fetchDeployArtifactStorage(
+          createApmApiClient(this.cfg)
+        );
+        this.minio = new MinioClient({
+          endPoint: storage.endpoint,
+          port: storage.port,
+          useSSL: storage.useSsl,
+          accessKey: storage.accessKey,
+          secretKey: storage.secretKey
+        });
+        this.bucket = storage.bucket;
+        await this.minio.ensureBucket(this.bucket);
+      }
+      listLocal(taskId) {
+        const alive = [
+          "STARTING",
+          "RUNNING",
+          "READY",
+          "STOPPING"
+        ];
+        const sessions = [...this.byId.values()].filter(
+          (s) => alive.includes(s.status)
+        );
+        return (taskId ? sessions.filter((s) => s.taskId === taskId) : sessions).map((s) => ({
+          id: s.id,
+          taskId: s.taskId,
+          key: s.key,
+          name: s.name,
+          status: s.status,
+          pid: s.pid,
+          ports: s.ports,
+          primaryUrl: s.primaryUrl,
+          nextSeq: s.nextSeq,
+          command: s.command,
+          cwd: s.cwd
+        }));
+      }
+      async start(opts) {
+        const key = opts.key.trim();
+        const existingId = this.byTaskKey.get(taskKey(opts.taskId, key));
+        const existing = existingId ? this.byId.get(existingId) : void 0;
+        if (existing?.child && (existing.status === "RUNNING" || existing.status === "READY" || existing.status === "STARTING")) {
+          return {
+            ok: true,
+            idempotent: true,
+            terminalId: existing.id,
+            status: existing.status,
+            pid: existing.pid,
+            ports: existing.ports,
+            primaryUrl: existing.primaryUrl
+          };
+        }
+        const api = createApmApiClient(this.cfg);
+        const upserted = await api.cli.webideUpsertTerminal({
+          taskId: opts.taskId,
+          key,
+          name: opts.name ?? key,
+          cwd: opts.cwd,
+          command: opts.command,
+          readyPattern: opts.readyPattern,
+          portsHint: opts.portsHint
+        });
+        const terminalId = upserted.id;
+        const objectPrefix = upserted.objectPrefix?.trim() || `terminals/${opts.taskId}/${terminalId}/`;
+        if (existing?.child) {
+          await this.stop(terminalId, { reason: "restart" });
+        }
+        const session = {
+          id: terminalId,
+          taskId: opts.taskId,
+          key,
+          name: (opts.name ?? key).trim() || key,
+          cwd: opts.cwd,
+          command: opts.command,
+          readyPattern: opts.readyPattern?.trim() || null,
+          status: "STARTING",
+          pid: null,
+          ports: opts.portsHint ? [...opts.portsHint] : [],
+          primaryUrl: null,
+          nextSeq: typeof upserted.nextSeq === "number" ? upserted.nextSeq : 0,
+          chunkCount: typeof upserted.chunkCount === "number" ? upserted.chunkCount : 0,
+          objectPrefix,
+          child: null,
+          stopping: false,
+          pendingLines: [],
+          syncChain: Promise.resolve()
+        };
+        this.byId.set(terminalId, session);
+        this.byTaskKey.set(taskKey(opts.taskId, key), terminalId);
+        this.pushSystemLine(
+          session,
+          `[apm] starting: ${opts.command} (cwd=${opts.cwd})`
+        );
+        const child = spawn(opts.command, {
+          cwd: opts.cwd,
+          shell: true,
+          detached: true,
+          env: process.env,
+          stdio: ["ignore", "pipe", "pipe"]
+        });
+        session.child = child;
+        session.pid = child.pid ?? null;
+        session.status = "RUNNING";
+        await api.cli.webideUpdateTerminalStatus({
+          id: terminalId,
+          status: "RUNNING",
+          pid: session.pid,
+          ports: session.ports,
+          primaryUrl: null
+        });
+        const onData = (stream) => (buf) => {
+          const text = buf.toString("utf8");
+          for (const line of text.split(/\r?\n/)) {
+            if (!line.length && text.endsWith("\n") === false) continue;
+            if (line.length === 0) continue;
+            this.pushLine(session, stream, line);
+          }
+          this.scheduleSync(session);
+          this.maybeUpdatePortsFromText(session, text);
+        };
+        child.stdout?.on("data", onData("stdout"));
+        child.stderr?.on("data", onData("stderr"));
+        child.on("exit", (code, signal) => {
+          void this.onExit(session, code, signal);
+        });
+        session.portTimer = setInterval(() => {
+          void this.probePorts(session);
+        }, PORT_PROBE_INTERVAL_MS);
+        this.scheduleSync(session);
+        return {
+          ok: true,
+          idempotent: false,
+          terminalId,
+          status: session.status,
+          pid: session.pid,
+          ports: session.ports,
+          primaryUrl: session.primaryUrl
+        };
+      }
+      async stop(terminalId, opts) {
+        const session = this.byId.get(terminalId);
+        const api = createApmApiClient(this.cfg);
+        if (!session) {
+          const pid2 = opts?.pid;
+          if (typeof pid2 === "number" && pid2 > 0) {
+            killProcessTree(pid2);
+            setTimeout(() => forceKillProcessTree(pid2), STOP_SIGKILL_MS);
+          }
+          try {
+            await api.cli.webideUpdateTerminalStatus({
+              id: terminalId,
+              status: "EXITED",
+              lastError: opts?.reason ?? "stopped"
+            });
+          } catch {
+          }
+          return { ok: true, terminalId, status: "EXITED" };
+        }
+        if (session.status === "EXITED" || session.status === "FAILED" || session.stopping) {
+          return { ok: true, terminalId, status: session.status };
+        }
+        session.stopping = true;
+        session.status = "STOPPING";
+        this.pushSystemLine(
+          session,
+          `[apm] stopping${opts?.reason ? `: ${opts.reason}` : ""}`
+        );
+        this.scheduleSync(session);
+        try {
+          await api.cli.webideUpdateTerminalStatus({
+            id: terminalId,
+            status: "STOPPING",
+            pid: session.pid
+          });
+        } catch {
+        }
+        const pid = session.pid ?? opts?.pid ?? null;
+        if (session.child && !session.child.killed) {
+          try {
+            if (session.child.pid) killProcessTree(session.child.pid);
+          } catch {
+          }
+        } else if (typeof pid === "number" && pid > 0) {
+          killProcessTree(pid);
+        }
+        const killPid = session.child?.pid ?? pid;
+        if (typeof killPid === "number" && killPid > 0) {
+          setTimeout(() => {
+            if (session.child && !session.child.killed) {
+              forceKillProcessTree(killPid);
+            }
+          }, STOP_SIGKILL_MS);
+        }
+        return { ok: true, terminalId, status: "STOPPING" };
+      }
+      async stopAllForTask(taskId, reason = "cache-cleanup") {
+        const ids = [...this.byId.values()].filter((s) => s.taskId === taskId).map((s) => s.id);
+        for (const id of ids) {
+          await this.stop(id, { reason });
+        }
+        return { ok: true, stopped: ids.length };
+      }
+      pushSystemLine(session, text) {
+        this.pushLine(session, "system", text);
+      }
+      pushLine(session, stream, text) {
+        session.nextSeq += 1;
+        session.pendingLines.push({
+          seq: session.nextSeq,
+          stream,
+          text,
+          ts: (/* @__PURE__ */ new Date()).toISOString()
+        });
+      }
+      maybeUpdatePortsFromText(session, text) {
+        const { ports, primaryUrl } = extractPortsAndUrl(text);
+        let changed = false;
+        for (const p of ports) {
+          if (!session.ports.includes(p)) {
+            session.ports.push(p);
+            changed = true;
+          }
+        }
+        session.ports.sort((a, b) => a - b);
+        if (primaryUrl && !session.primaryUrl) {
+          session.primaryUrl = primaryUrl;
+          changed = true;
+        }
+        if (changed) {
+          void this.syncStatus(session);
+        }
+        if (session.readyPattern && session.status === "RUNNING" && new RegExp(session.readyPattern).test(text)) {
+          session.status = "READY";
+          void this.syncStatus(session);
+        } else if (session.status === "RUNNING" && (session.ports.length > 0 || session.primaryUrl)) {
+          session.status = "READY";
+          void this.syncStatus(session);
+        }
+      }
+      async probePorts(session) {
+        if (session.status !== "RUNNING" && session.status !== "STARTING" && session.status !== "READY") {
+          return;
+        }
+        if (!session.pid) return;
+        const ports = await probeListenPorts(session.pid);
+        if (ports.length === 0) return;
+        let changed = false;
+        for (const p of ports) {
+          if (!session.ports.includes(p)) {
+            session.ports.push(p);
+            changed = true;
+          }
+        }
+        if (changed) {
+          session.ports.sort((a, b) => a - b);
+          if (!session.primaryUrl && session.ports[0]) {
+            session.primaryUrl = `http://127.0.0.1:${session.ports[0]}`;
+          }
+          if (session.status === "RUNNING" || session.status === "STARTING") {
+            session.status = "READY";
+          }
+          void this.syncStatus(session);
+        }
+      }
+      async syncStatus(session) {
+        const api = createApmApiClient(this.cfg);
+        try {
+          await api.cli.webideUpdateTerminalStatus({
+            id: session.id,
+            status: session.status,
+            pid: session.pid,
+            ports: session.ports,
+            primaryUrl: session.primaryUrl
+          });
+        } catch (err) {
+          console.warn(
+            "[apm] terminal status sync failed:",
+            err instanceof Error ? err.message : err
+          );
+        }
+      }
+      scheduleSync(session) {
+        if (session.syncTimer) return;
+        session.syncTimer = setTimeout(() => {
+          session.syncTimer = void 0;
+          session.syncChain = session.syncChain.then(() => this.flushPending(session)).catch((err) => {
+            console.warn(
+              "[apm] terminal log flush failed:",
+              err instanceof Error ? err.message : err
+            );
+          });
+        }, SYNC_INTERVAL_MS);
+      }
+      async flushPending(session) {
+        if (session.pendingLines.length === 0) return;
+        const batch = session.pendingLines.splice(0, session.pendingLines.length);
+        await this.ensureMinio();
+        const seqStart = batch[0].seq;
+        const seqEnd = batch.at(-1).seq;
+        const ci = session.chunkCount;
+        const key = chunkKey(session.objectPrefix, ci);
+        const body = Buffer.from(
+          JSON.stringify({ seqStart, seqEnd, lines: batch }),
+          "utf8"
+        );
+        await this.minio.putObject(this.bucket, key, body, {
+          "Content-Type": "application/json"
+        });
+        session.chunkCount = ci + 1;
+        const api = createApmApiClient(this.cfg);
+        await api.cli.webideUpdateTerminalMeta({
+          id: session.id,
+          nextSeq: session.nextSeq,
+          chunkCount: session.chunkCount
+        });
+        if (!session.stopping && (session.status === "RUNNING" || session.status === "READY")) {
+          try {
+            const listed = await api.cli.webideListTerminals({
+              taskId: session.taskId
+            });
+            const remote = listed.terminals?.find((t) => t.id === session.id);
+            if (remote?.status === "STOPPING") {
+              await this.stop(session.id, {
+                pid: remote.pid ?? session.pid,
+                reason: "server STOPPING"
+              });
+            }
+          } catch {
+          }
+        }
+      }
+      async onExit(session, code, signal) {
+        if (session.portTimer) {
+          clearInterval(session.portTimer);
+          session.portTimer = void 0;
+        }
+        session.child = null;
+        const exitCode = code ?? (signal ? 1 : 0);
+        session.status = session.stopping || exitCode === 0 ? "EXITED" : "FAILED";
+        this.pushSystemLine(
+          session,
+          `[apm] exited code=${exitCode}${signal ? ` signal=${signal}` : ""}`
+        );
+        await session.syncChain;
+        await this.flushPending(session);
+        const api = createApmApiClient(this.cfg);
+        try {
+          await api.cli.webideUpdateTerminalStatus({
+            id: session.id,
+            status: session.status,
+            pid: session.pid,
+            exitCode,
+            ports: session.ports,
+            primaryUrl: session.primaryUrl
+          });
+        } catch (err) {
+          console.warn(
+            "[apm] terminal exit status sync failed:",
+            err instanceof Error ? err.message : err
+          );
+        }
+      }
+    };
+    registrySingleton = null;
+  }
+});
+
+// src/index.ts
+import { Command } from "commander";
+init_config();
 
 // src/commands/init.ts
 import { join as join5 } from "path";
 import { readFileSync as readFileSync4, writeFileSync as writeFileSync5 } from "fs";
 
 // src/command-utils.ts
+init_config();
 import {
   copyFileSync,
   existsSync,
@@ -361,206 +1352,16 @@ async function copyTemplateFiles(targetDir, workdir = resolveWorkdirPath()) {
     copyTemplateEntry(join2(templateDir, name), join2(resolvedTarget, name));
   }
   for (const subdir of WORKSPACE_TEMPLATE_SUBDIRS) {
-    mkdirSync2(toFsPath(join2(resolvedTarget, subdir)), { recursive: true });
-  }
-  assertTemplateCopiedToApm(resolvedTarget, resolve2(workdir));
-}
-
-// src/deployment-config-sync.ts
-import { join as join3 } from "path";
-import { writeFileSync as writeFileSync3 } from "fs";
-
-// 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"
-    }),
-    webideRecommendPlan: defineEndpoint({
-      method: "PUT",
-      path: "/cli/webide/plan-recommendation"
-    }),
-    webideUpsertPlan: defineEndpoint({
-      method: "PUT",
-      path: "/cli/webide/plan"
-    }),
-    webideReplaceTestCases: defineEndpoint({
-      method: "PUT",
-      path: "/cli/webide/test-cases"
-    }),
-    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"
-    }),
-    createWebIdeDraftPullRequest: defineEndpoint({
-      method: "POST",
-      path: "/cli/webide/draft-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/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]
-  });
+    mkdirSync2(toFsPath(join2(resolvedTarget, subdir)), { recursive: true });
+  }
+  assertTemplateCopiedToApm(resolvedTarget, resolve2(workdir));
 }
 
+// src/deployment-config-sync.ts
+init_client();
+import { join as join3 } from "path";
+import { writeFileSync as writeFileSync3 } from "fs";
+
 // src/git-remote.ts
 import { execFile } from "child_process";
 import { promisify } from "util";
@@ -648,6 +1449,22 @@ async function hasUpstream(cwd) {
     return false;
   }
 }
+async function pushCurrentBranch(cwd) {
+  if (!await isGitRepo(cwd)) {
+    return false;
+  }
+  const originUrl = await tryReadGitOriginUrl(cwd);
+  if (!originUrl) {
+    console.log("[apm] \u672A\u914D\u7F6E remote.origin\uFF0C\u8DF3\u8FC7 push");
+    return false;
+  }
+  if (await hasUpstream(cwd)) {
+    await execGit(cwd, ["push"]);
+  } else {
+    await execGit(cwd, ["push", "-u", "origin", "HEAD"]);
+  }
+  return true;
+}
 var GITIGNORE_COMMIT_MESSAGE = "chore(apm): ignore .apm directory";
 async function commitAndPushGitignore(workdir) {
   if (!await isGitRepo(workdir)) {
@@ -657,17 +1474,12 @@ async function commitAndPushGitignore(workdir) {
   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"]);
+  const pushed = await pushCurrentBranch(workdir);
+  if (pushed) {
+    console.log("[apm] \u5DF2\u63A8\u9001 .gitignore");
   } else {
-    await execGit(workdir, ["push", "-u", "origin", "HEAD"]);
+    console.log("[apm] \u672A\u914D\u7F6E remote.origin\uFF0C\u8BF7\u7A0D\u540E\u624B\u52A8 push .gitignore");
   }
-  console.log("[apm] \u5DF2\u63A8\u9001 .gitignore");
 }
 
 // src/baseline-resolve.ts
@@ -754,6 +1566,7 @@ async function resolveBranchBaseline(api, sessionId, workdirPath) {
 }
 
 // src/deployment-config-sync.ts
+init_config();
 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) {
@@ -817,6 +1630,8 @@ ${diagnostic ?? ""}
 }
 
 // src/repository-project-documents-sync.ts
+init_client();
+init_config();
 import {
   existsSync as existsSync2,
   readdirSync as readdirSync2,
@@ -1082,6 +1897,8 @@ async function runInit(name) {
 }
 
 // src/commands/login.ts
+init_config();
+init_client();
 import { existsSync as existsSync3 } from "fs";
 import { ApiError } from "listpage-http";
 async function runLogin(opts) {
@@ -1143,6 +1960,7 @@ async function runLogin(opts) {
 }
 
 // src/commands/branch.ts
+init_client();
 var SESSION_BRANCH_PREFIX = "feat/session-";
 function branchNameForSession(sessionId) {
   const id = sessionId.trim();
@@ -1266,6 +2084,9 @@ async function runBranch(sessionId, options = {}) {
   return ensureFeatureBranch(branch, baseline.defaultBranch, options);
 }
 
+// src/commands/clean-branches.ts
+init_client();
+
 // src/commands/session-branch-prune.ts
 var TASK_STATUS_LABEL = {
   OPEN: "\u5F85\u5F00\u59CB",
@@ -1588,6 +2409,7 @@ async function runCleanBranches(options = {}) {
 }
 
 // src/commands/pull.ts
+init_client();
 import { writeFileSync as writeFileSync9 } from "fs";
 import { join as join9 } from "path";
 import { stringify as yamlStringify } from "yaml";
@@ -1698,6 +2520,7 @@ async function syncSessionAttachments(cfg, sessionId, attachments, apmRoot) {
 }
 
 // src/rules-sync.ts
+init_client();
 import { basename as basename2, extname as extname2, join as join8 } from "path";
 import { existsSync as existsSync6, readFileSync as readFileSync6, rmSync as rmSync3, writeFileSync as writeFileSync8 } from "fs";
 
@@ -2120,6 +2943,7 @@ async function runUpdate(options = {}) {
 }
 
 // src/commands/update-skills.ts
+init_client();
 import { existsSync as existsSync7, mkdirSync as mkdirSync4, statSync as statSync3 } from "fs";
 import { join as join11 } from "path";
 async function syncWorkspaceSkills(cfg, workdir) {
@@ -2383,7 +3207,11 @@ function validateAssumptionsMarkdown(markdown, source) {
   };
 }
 
+// src/commands/sync-document.ts
+init_client();
+
 // src/commands/sync-session-documents.ts
+init_client();
 import { existsSync as existsSync9, readdirSync as readdirSync4, readFileSync as readFileSync8 } from "fs";
 import { join as join12 } from "path";
 function listLocalMarkdownFiles(docsDir) {
@@ -2504,6 +3332,7 @@ async function runSyncDocument(sessionId, options) {
 }
 
 // src/commands/dev-gate.ts
+init_client();
 async function runDevGate(sessionId, source) {
   const trimmedId = sessionId.trim();
   if (!trimmedId) {
@@ -2523,6 +3352,7 @@ async function runDevGate(sessionId, source) {
 }
 
 // src/commands/append-message.ts
+init_client();
 async function appendMessageContent(cfg, messageId, content) {
   const trimmedId = messageId.trim();
   if (!trimmedId) {
@@ -2551,6 +3381,7 @@ async function runAppendMessage(options) {
 }
 
 // src/commands/update-message-status.ts
+init_client();
 var VALID_STATUSES = [
   "CREATED",
   "QUEUED",
@@ -2579,8 +3410,10 @@ async function runUpdateMessageStatus(options) {
 }
 
 // src/commands/connect.ts
+init_client();
 import WebSocket from "ws";
 import { setTimeout as delay3 } from "node:timers/promises";
+init_config();
 
 // src/ws/protocol.ts
 function nonEmptyString(v) {
@@ -2762,13 +3595,38 @@ function validateWebIdeCacheCleanupPush(o) {
     }
   };
 }
+function validateWebIdeTerminalStopPush(o) {
+  if (o.type !== "webide-terminal-stop") {
+    return { ok: false, reason: "\u671F\u671B webide-terminal-stop" };
+  }
+  if (!nonEmptyString(o.taskId)) {
+    return { ok: false, reason: "webide-terminal-stop \u7F3A\u5C11 taskId" };
+  }
+  if (!nonEmptyString(o.terminalId)) {
+    return { ok: false, reason: "webide-terminal-stop \u7F3A\u5C11 terminalId" };
+  }
+  if (!nonEmptyString(o.key)) {
+    return { ok: false, reason: "webide-terminal-stop \u7F3A\u5C11 key" };
+  }
+  const pid = typeof o.pid === "number" && Number.isFinite(o.pid) ? Math.trunc(o.pid) : o.pid === null ? null : void 0;
+  return {
+    ok: true,
+    data: {
+      type: "webide-terminal-stop",
+      taskId: o.taskId.trim(),
+      terminalId: o.terminalId.trim(),
+      key: o.key.trim(),
+      ...pid !== void 0 ? { pid } : {}
+    }
+  };
+}
 function validateAgentWsMessage(value, kind) {
   if (typeof value !== "object" || value === null) {
     return { ok: false, reason: "\u6D88\u606F\u4F53\u4E0D\u662F JSON \u5BF9\u8C61" };
   }
   const o = value;
   const type = o.type;
-  if (type !== "heartbeat" && type !== "message" && type !== "webide-message" && type !== "cancel" && type !== "deploy" && type !== "session-cache-cleanup" && type !== "webide-cache-cleanup") {
+  if (type !== "heartbeat" && type !== "message" && type !== "webide-message" && type !== "cancel" && type !== "deploy" && type !== "session-cache-cleanup" && type !== "webide-cache-cleanup" && type !== "webide-terminal-stop") {
     return { ok: false, reason: `\u672A\u77E5 type: ${String(type)}` };
   }
   if (kind === "heartbeat" || type === "heartbeat") {
@@ -2786,12 +3644,18 @@ function validateAgentWsMessage(value, kind) {
   if (type === "webide-cache-cleanup") {
     return validateWebIdeCacheCleanupPush(o);
   }
+  if (type === "webide-terminal-stop") {
+    return validateWebIdeTerminalStopPush(o);
+  }
   if (type === "webide-message") {
     return validateWebIdeMessagePush(o);
   }
   return validateMessagePush(o);
 }
 
+// src/commands/connect/deploy-run.ts
+init_client();
+
 // src/commands/deploy/deploy-execute.ts
 import path11 from "node:path";
 
@@ -3052,353 +3916,106 @@ function resolveWisdomBackendDeployFromApmConfig(cfg) {
     console.error("apm.config.json \u4E2D healthCheck.port \u987B\u4E3A\u6B63\u6574\u6570");
     process.exit(1);
   }
-  if (!Number.isFinite(healthTimeout) || !Number.isInteger(healthTimeout) || healthTimeout < 1) {
-    console.error("apm.config.json \u4E2D healthCheck.timeout \u987B\u4E3A\u6B63\u6574\u6570");
-    process.exit(1);
-  }
-  const mavenLocalRepo = resolveMavenLocalRepoWithSource();
-  return {
-    projectName,
-    host: req(w.host, "host", "wisdomDeploy").trim(),
-    port: reqPositiveInt(w.port, "port", "wisdomDeploy"),
-    username: req(w.username, "username", "wisdomDeploy").trim(),
-    password: req(w.password, "password", "wisdomDeploy").trim(),
-    remoteVueDistDir: req(w.remotePath, "remotePath", "wisdomDeploy").trim(),
-    remoteAppDir,
-    remoteLibDir: `${remoteAppDir}/lib`,
-    startupJar: posixBasename(jarPath),
-    packageName: `${projectName}.jar.zip`,
-    mavenLocalRepo: mavenLocalRepo.path,
-    mavenLocalRepoSource: mavenLocalRepo.source,
-    mavenLocalRepoSourceDetail: mavenLocalRepo.sourceDetail,
-    healthCheckPort: healthPort,
-    healthCheckContext: req(h.context, "context", "healthCheck").trim(),
-    healthCheckTimeout: healthTimeout,
-    mode: resolveWisdomDeployMode(w.mode)
-  };
-}
-
-// src/commands/deploy/internal/apm-config.ts
-function loadApmConfig(options) {
-  const p = resolve4(
-    process.cwd(),
-    options?.configPath ?? resolve4(workspaceApmDir(), "apm.config.json")
-  );
-  if (!existsSync12(p)) {
-    console.error(`\u672A\u627E\u5230\u914D\u7F6E\u6587\u4EF6\uFF1A${p}`);
-    process.exit(1);
-  }
-  try {
-    const raw = readFileSync11(p, "utf8");
-    return JSON.parse(raw);
-  } catch (e) {
-    console.error(`\u65E0\u6CD5\u89E3\u6790 apm.config.json\uFF1A${p}`, e);
-    process.exit(1);
-  }
-}
-
-// src/commands/deploy/internal/deploy-hints.ts
-function isProductionDeployEnv(env) {
-  const normalized = env.trim().toLowerCase();
-  return normalized === "online" || normalized === "production" || normalized === "prod";
-}
-function formatMissingWisdomDeployLines() {
-  return [
-    "[apm] \u65E0\u6CD5\u6267\u884C apm deploy\uFF1A\u8BF7\u5728 apm.config.json \u4E2D\u914D\u7F6E wisdomDeploy\uFF08host\u3001remotePath\uFF09"
-  ];
-}
-function formatWisdomFrontendBuildNotConfiguredLines(env, packageJsonPath) {
-  if (isProductionDeployEnv(env)) {
-    return [
-      `[apm] \u65E0\u6CD5\u6267\u884C\u524D\u7AEF\u90E8\u7F72\uFF1A${packageJsonPath} \u4E2D\u672A\u627E\u5230 build:${env} \u6216 build \u811A\u672C`,
-      "[apm] \u8BF7\u914D\u7F6E npm run build:online \u6216 npm run build \u540E\u518D\u8BD5"
-    ];
-  }
-  return [
-    `[apm] \u65E0\u6CD5\u6267\u884C\u524D\u7AEF\u90E8\u7F72\uFF1A${packageJsonPath} \u4E2D\u672A\u627E\u5230 build:${env} \u811A\u672C`,
-    "[apm] \u8BF7\u914D\u7F6E npm run build:test \u540E\u518D\u8BD5"
-  ];
-}
-
-// src/commands/deploy/deploy-errors.ts
-var DeployExecutionError = class extends Error {
-  exitCode;
-  output;
-  constructor(message, exitCode, output = "") {
-    super(message);
-    this.name = "DeployExecutionError";
-    this.exitCode = exitCode;
-    this.output = output;
-  }
-};
-
-// src/commands/deploy/deploy-debug-log.ts
-import { spawnSync as spawnSync4 } from "node:child_process";
-import { existsSync as existsSync16 } from "node:fs";
-import { dirname as dirname5, join as join17 } from "node:path";
-
-// src/commands/deploy/internal/deploy-artifact-minio.ts
-import { readFile as readFile2 } from "node:fs/promises";
-
-// src/commands/deploy/internal/minio.ts
-import { statSync as statSync5 } from "node:fs";
-import { readdir, readFile } from "node:fs/promises";
-import path from "node:path";
-import * as Minio from "minio";
-var DEFAULT_MAX_FILE_SIZE_MB = 50;
-async function isDirectoryPath(dir) {
-  try {
-    const st = statSync5(dir);
-    return st.isDirectory();
-  } catch {
-    return false;
-  }
-}
-function sanitizeRelativePath(rel) {
-  const norm = rel.replace(/\\/g, "/").replace(/^\/+/, "");
-  const segments = norm.split("/").filter(Boolean);
-  for (const s of segments) {
-    if (s === "." || s === "..") {
-      throw new Error(`\u975E\u6CD5\u76F8\u5BF9\u8DEF\u5F84\u7247\u6BB5\uFF1A${s}`);
-    }
-  }
-  return segments.join("/");
-}
-async function collectFiles(root) {
-  const out = [];
-  async function walk(dir, prefix) {
-    const entries = await readdir(dir, { withFileTypes: true });
-    for (const e of entries) {
-      const name = e.name;
-      if (name === "." || name === "..") {
-        continue;
-      }
-      const abs = path.join(dir, name);
-      const rel = prefix ? `${prefix}/${name}` : name;
-      if (e.isDirectory()) {
-        await walk(abs, rel);
-      } else if (e.isFile()) {
-        const st = statSync5(abs);
-        out.push({
-          absPath: abs,
-          relativePath: rel.replace(/\\/g, "/"),
-          size: st.size
-        });
-      }
-    }
-  }
-  await walk(root, "");
-  out.sort((a, b) => a.relativePath.localeCompare(b.relativePath));
-  return out;
-}
-async function readArtifactFile(absPath) {
-  return readFile(absPath);
-}
-function toMB(bytes) {
-  return Math.round(bytes / (1024 * 1024) * 1e3) / 1e3;
-}
-var MIME = {
-  ".html": "text/html; charset=utf-8",
-  ".css": "text/css; charset=utf-8",
-  ".js": "application/javascript; charset=utf-8",
-  ".json": "application/json; charset=utf-8",
-  ".svg": "image/svg+xml",
-  ".png": "image/png",
-  ".jpg": "image/jpeg",
-  ".jpeg": "image/jpeg",
-  ".gif": "image/gif",
-  ".webp": "image/webp",
-  ".woff": "font/woff",
-  ".woff2": "font/woff2",
-  ".ttf": "font/ttf",
-  ".ico": "image/x-icon",
-  ".txt": "text/plain; charset=utf-8",
-  ".map": "application/json"
-};
-function detectMimeType(filePath) {
-  const ext = path.extname(filePath).toLowerCase();
-  return MIME[ext] ?? "";
-}
-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((resolve7, reject) => {
-      objectsStream.on("data", (obj) => {
-        if (obj.name) {
-          keys.push(obj.name);
-        }
-      });
-      objectsStream.on("error", reject);
-      objectsStream.on("end", resolve7);
-    });
-    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
-var APM_DEPLOYMENT_RUN_ID_ENV = "APM_DEPLOYMENT_RUN_ID";
-function formatDeployArtifactTimestamp(date = /* @__PURE__ */ new Date()) {
-  const pad2 = (n) => String(n).padStart(2, "0");
-  return `${date.getFullYear()}${pad2(date.getMonth() + 1)}${pad2(date.getDate())}${pad2(date.getHours())}${pad2(date.getMinutes())}${pad2(date.getSeconds())}`;
-}
-function sanitizeDeployProjectName(name) {
-  const trimmed = name.trim().replace(/\\/g, "/");
-  const base = trimmed.split("/").filter(Boolean).pop() ?? trimmed;
-  try {
-    return sanitizeRelativePath(base.replace(/[/\\:*?"<>|]/g, "_"));
-  } catch {
-    return "project";
-  }
-}
-function buildDeployArtifactFileName(kind, projectName, timestamp = formatDeployArtifactTimestamp()) {
-  const safeName = sanitizeDeployProjectName(projectName);
-  const suffix = kind === "frontend" ? "dist.zip" : "jar.zip";
-  return `${timestamp}-${safeName}.${suffix}`;
-}
-function buildDeployArtifactObjectKey(projectName, fileName) {
-  const safeProject = sanitizeDeployProjectName(projectName);
-  return `deploy/${safeProject}/${fileName}`;
-}
-function resolveDeploymentRunIdFromEnv() {
-  const raw = process.env[APM_DEPLOYMENT_RUN_ID_ENV]?.trim();
-  return raw || null;
-}
-async function fetchDeployArtifactStorage(api) {
-  return api.cli.getDeployArtifactStorage(void 0);
-}
-async function uploadDeployArtifactZip(options) {
-  const deploymentRunId = options.deploymentRunId ?? resolveDeploymentRunIdFromEnv();
-  if (!deploymentRunId && !options.uploadWithoutRunId) {
-    return null;
-  }
-  const cfg = await tryReadApmConfig();
-  if (!cfg || !resolveApiKey(cfg)) {
-    console.warn("[apm] \u672A\u767B\u5F55\uFF0C\u8DF3\u8FC7 MinIO \u90E8\u7F72\u4EA7\u7269\u5F52\u6863");
-    return null;
-  }
-  const api = options.api ?? createApmApiClient(cfg);
-  let storage;
-  try {
-    storage = await fetchDeployArtifactStorage(api);
-  } catch (error) {
-    const detail = error instanceof Error ? error.message : String(error);
-    console.warn(`[apm] \u83B7\u53D6 MinIO \u914D\u7F6E\u5931\u8D25\uFF0C\u8DF3\u8FC7\u90E8\u7F72\u4EA7\u7269\u5F52\u6863: ${detail}`);
-    return null;
+  if (!Number.isFinite(healthTimeout) || !Number.isInteger(healthTimeout) || healthTimeout < 1) {
+    console.error("apm.config.json \u4E2D healthCheck.timeout \u987B\u4E3A\u6B63\u6574\u6570");
+    process.exit(1);
   }
-  const fileName = buildDeployArtifactFileName(
-    options.kind,
-    options.projectName,
-    options.timestamp
+  const mavenLocalRepo = resolveMavenLocalRepoWithSource();
+  return {
+    projectName,
+    host: req(w.host, "host", "wisdomDeploy").trim(),
+    port: reqPositiveInt(w.port, "port", "wisdomDeploy"),
+    username: req(w.username, "username", "wisdomDeploy").trim(),
+    password: req(w.password, "password", "wisdomDeploy").trim(),
+    remoteVueDistDir: req(w.remotePath, "remotePath", "wisdomDeploy").trim(),
+    remoteAppDir,
+    remoteLibDir: `${remoteAppDir}/lib`,
+    startupJar: posixBasename(jarPath),
+    packageName: `${projectName}.jar.zip`,
+    mavenLocalRepo: mavenLocalRepo.path,
+    mavenLocalRepoSource: mavenLocalRepo.source,
+    mavenLocalRepoSourceDetail: mavenLocalRepo.sourceDetail,
+    healthCheckPort: healthPort,
+    healthCheckContext: req(h.context, "context", "healthCheck").trim(),
+    healthCheckTimeout: healthTimeout,
+    mode: resolveWisdomDeployMode(w.mode)
+  };
+}
+
+// src/commands/deploy/internal/apm-config.ts
+function loadApmConfig(options) {
+  const p = resolve4(
+    process.cwd(),
+    options?.configPath ?? resolve4(workspaceApmDir(), "apm.config.json")
   );
-  const objectKey = buildDeployArtifactObjectKey(options.projectName, fileName);
-  let body;
-  try {
-    body = await readFile2(options.zipPath);
-  } catch (error) {
-    const detail = error instanceof Error ? error.message : String(error);
-    console.warn(`[apm] \u8BFB\u53D6\u90E8\u7F72\u4EA7\u7269 zip \u5931\u8D25\uFF0C\u8DF3\u8FC7 MinIO \u5F52\u6863: ${detail}`);
-    return null;
+  if (!existsSync12(p)) {
+    console.error(`\u672A\u627E\u5230\u914D\u7F6E\u6587\u4EF6\uFF1A${p}`);
+    process.exit(1);
   }
   try {
-    const client = new MinioClient({
-      endPoint: storage.endpoint,
-      port: storage.port,
-      useSSL: storage.useSsl,
-      accessKey: storage.accessKey,
-      secretKey: storage.secretKey
-    });
-    await client.ensureBucket(storage.bucket);
-    await client.putObject(storage.bucket, objectKey, body, {
-      "Content-Type": "application/zip"
-    });
-    console.error(
-      `[apm] \u672C\u5730\u76F4\u4F20 MinIO\uFF08\u4E0D\u7ECF\u5E73\u53F0\u670D\u52A1\u5668\uFF09: ${storage.endpoint}:${storage.port}/${storage.bucket}/${objectKey} (${(body.length / 1024 / 1024).toFixed(
-        2
-      )} MB)`
-    );
-  } catch (error) {
-    const detail = error instanceof Error ? error.message : String(error);
-    console.warn(`[apm] MinIO \u90E8\u7F72\u4EA7\u7269\u5F52\u6863\u5931\u8D25: ${detail}`);
-    return null;
+    const raw = readFileSync11(p, "utf8");
+    return JSON.parse(raw);
+  } catch (e) {
+    console.error(`\u65E0\u6CD5\u89E3\u6790 apm.config.json\uFF1A${p}`, e);
+    process.exit(1);
   }
-  if (deploymentRunId) {
-    try {
-      await api.cli.attachTaskDeploymentArtifact({
-        id: deploymentRunId,
-        artifactObjectKey: objectKey,
-        artifactFileName: fileName
-      });
-      console.error(
-        `[apm] \u5DF2\u7ED1\u5B9A\u90E8\u7F72\u4EA7\u7269\u5230\u8BB0\u5F55 id=${deploymentRunId} file=${fileName}`
-      );
-    } catch (error) {
-      const detail = error instanceof Error ? error.message : String(error);
-      console.warn(`[apm] \u7ED1\u5B9A\u90E8\u7F72\u4EA7\u7269\u5230\u8BB0\u5F55\u5931\u8D25: ${detail}`);
-      return null;
-    }
+}
+
+// src/commands/deploy/internal/deploy-hints.ts
+function isProductionDeployEnv(env) {
+  const normalized = env.trim().toLowerCase();
+  return normalized === "online" || normalized === "production" || normalized === "prod";
+}
+function formatMissingWisdomDeployLines() {
+  return [
+    "[apm] \u65E0\u6CD5\u6267\u884C apm deploy\uFF1A\u8BF7\u5728 apm.config.json \u4E2D\u914D\u7F6E wisdomDeploy\uFF08host\u3001remotePath\uFF09"
+  ];
+}
+function formatWisdomFrontendBuildNotConfiguredLines(env, packageJsonPath) {
+  if (isProductionDeployEnv(env)) {
+    return [
+      `[apm] \u65E0\u6CD5\u6267\u884C\u524D\u7AEF\u90E8\u7F72\uFF1A${packageJsonPath} \u4E2D\u672A\u627E\u5230 build:${env} \u6216 build \u811A\u672C`,
+      "[apm] \u8BF7\u914D\u7F6E npm run build:online \u6216 npm run build \u540E\u518D\u8BD5"
+    ];
   }
-  return {
-    objectKey,
-    fileName,
-    bucket: storage.bucket
-  };
+  return [
+    `[apm] \u65E0\u6CD5\u6267\u884C\u524D\u7AEF\u90E8\u7F72\uFF1A${packageJsonPath} \u4E2D\u672A\u627E\u5230 build:${env} \u811A\u672C`,
+    "[apm] \u8BF7\u914D\u7F6E npm run build:test \u540E\u518D\u8BD5"
+  ];
 }
 
+// src/commands/deploy/deploy-errors.ts
+var DeployExecutionError = class extends Error {
+  exitCode;
+  output;
+  constructor(message, exitCode, output = "") {
+    super(message);
+    this.name = "DeployExecutionError";
+    this.exitCode = exitCode;
+    this.output = output;
+  }
+};
+
+// src/commands/deploy/deploy-debug-log.ts
+init_deploy_artifact_minio();
+import { spawnSync as spawnSync4 } from "node:child_process";
+import { existsSync as existsSync16 } from "node:fs";
+import { dirname as dirname5, join as join17 } from "node:path";
+
 // src/commands/deploy/internal/deploy-shell-env.ts
 import { spawnSync as spawnSync3 } from "node:child_process";
 import { existsSync as existsSync15 } from "node:fs";
 import { dirname as dirname4, join as join16 } from "node:path";
 
 // src/commands/daemon.ts
+init_config();
 import { spawnSync as spawnSync2 } from "child_process";
 import { setTimeout as delay } from "node:timers/promises";
 import { existsSync as existsSync14, mkdirSync as mkdirSync6, unlinkSync as unlinkSync2, writeFileSync as writeFileSync11 } from "fs";
 import { join as join15 } from "path";
 
 // src/commands/connect-lock.ts
+init_config();
 import {
   existsSync as existsSync13,
   mkdirSync as mkdirSync5,
@@ -4533,6 +5150,7 @@ function runDeployShellCommand(command, cwd, captureOutput) {
 
 // src/commands/deploy/internal/wisdom-backend/index.ts
 import path9 from "node:path";
+init_deploy_artifact_minio();
 
 // src/commands/deploy/internal/wisdom-backend/jar-incremental.ts
 import {
@@ -4601,6 +5219,8 @@ import SftpClient from "ssh2-sftp-client";
 import { readdir as readdir2, readFile as readFile3, unlink, writeFile } from "node:fs/promises";
 import path3 from "node:path";
 import JSZip from "jszip";
+init_deploy_artifact_minio();
+init_minio();
 async function addDirToZip(dir, zipFolder) {
   const entries = await readdir2(dir, { withFileTypes: true });
   for (const entry of entries) {
@@ -4689,6 +5309,7 @@ async function packDirectoryWithMinioArchive(input) {
 }
 
 // src/commands/deploy/internal/wisdom-sftp.ts
+init_deploy_artifact_minio();
 var SFTP_UPLOAD_MAX_ATTEMPTS = 3;
 var SFTP_FAST_PUT_OPTIONS = {
   chunkSize: 64 * 1024,
@@ -5688,6 +6309,8 @@ async function executeWisdomDeploy(options) {
 }
 
 // src/commands/deploy/internal/deploy-baseline-sync.ts
+init_client();
+init_config();
 var LOG_PREFIX2 = "[apm] \u90E8\u7F72\u524D\u57FA\u7EBF\u540C\u6B65:";
 function formatGitError(error) {
   return error instanceof Error ? error.message : String(error);
@@ -5895,6 +6518,9 @@ function printDeployExecutionError(error) {
   console.error(error.message);
 }
 
+// src/commands/deploy/platform/deploy-run-coordinator.ts
+init_deploy_artifact_minio();
+
 // src/commands/deploy/platform/deploy-console-capture.ts
 function captureDeployConsole(logSyncer) {
   const chunks = [];
@@ -6623,6 +7249,7 @@ function clearSessionAgentId(workdir, sessionId, user) {
 }
 
 // src/commands/connect/cursor-message-log.ts
+init_client();
 var CURSOR_MESSAGE_LOG_SYNC_INTERVAL_MS = 2e3;
 function createThrottledCursorMessageLogSync(cfg, ctx, onError) {
   let lastRunAt = 0;
@@ -6790,7 +7417,38 @@ ${payload}`;
   };
 }
 
+// src/commands/connect/webide-merge-tools.ts
+init_client();
+function createMergeWebIdePullRequestsTool(options) {
+  const { cfg, taskId } = options;
+  return {
+    description: "Merge all open pull requests for this WebIDE task. Call once with confirmedConflictFree=true. No baseline sync or review is required before calling.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        confirmedConflictFree: {
+          type: "boolean",
+          description: "Must be true to confirm you intend to merge this task's open PRs now."
+        }
+      },
+      required: ["confirmedConflictFree"]
+    },
+    execute: async (args) => {
+      if (args.confirmedConflictFree !== true) {
+        throw new Error(
+          "MergeWebIdePullRequests \u8981\u6C42 confirmedConflictFree=true\u3002"
+        );
+      }
+      const api = createApmApiClient(cfg);
+      console.log(`[apm] MergeWebIdePullRequests taskId=${taskId}`);
+      const result = await api.cli.webideMergePullRequests({ taskId });
+      return JSON.stringify(result, null, 2);
+    }
+  };
+}
+
 // src/commands/connect/webide-plan-tools.ts
+init_client();
 function asString(value) {
   return typeof value === "string" ? value.trim() : "";
 }
@@ -6860,6 +7518,7 @@ function createUpsertWebIdePlanTool(options) {
 }
 
 // src/commands/connect/webide-test-case-tools.ts
+init_client();
 function asString2(value) {
   return typeof value === "string" ? value.trim() : "";
 }
@@ -6944,6 +7603,165 @@ function createUpsertWebIdeTestCasesTool(options) {
   };
 }
 
+// src/commands/connect/webide-terminal-tools.ts
+init_client();
+function asString3(value) {
+  return typeof value === "string" ? value.trim() : "";
+}
+function asPorts(value) {
+  if (!Array.isArray(value)) return void 0;
+  const ports = value.map((p) => typeof p === "number" ? p : Number(p)).filter((p) => Number.isFinite(p) && p > 0 && p < 65536).map((p) => Math.trunc(p));
+  return ports.length ? ports : void 0;
+}
+function createWebIdeTerminalTools(options) {
+  const { cfg, taskId, workdir, rpc } = options;
+  const StartWebIdeTerminal = {
+    description: "Start a long-running WebIDE terminal (e.g. frontend/backend dev server). Process outlives this message. Same key already RUNNING/READY returns idempotently. Do NOT use Shell for long-lived dev servers. Returns terminalId, pid, ports.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        key: {
+          type: "string",
+          description: "Stable key, e.g. frontend / backend"
+        },
+        name: { type: "string", description: "Display name" },
+        cwd: {
+          type: "string",
+          description: "Working directory (absolute or under workspace)"
+        },
+        command: {
+          type: "string",
+          description: "Shell command to run, e.g. pnpm dev"
+        },
+        readyPattern: {
+          type: "string",
+          description: "Optional regex; when matched in logs, status becomes READY"
+        },
+        portsHint: {
+          type: "array",
+          items: { type: "number" },
+          description: "Optional expected listen ports"
+        }
+      },
+      required: ["key", "cwd", "command"]
+    },
+    execute: async (args) => {
+      const key = asString3(args.key);
+      const cwd = asString3(args.cwd) || workdir;
+      const command = asString3(args.command);
+      if (!key || !command) {
+        return {
+          content: [{ type: "text", text: "key / command \u4E0D\u80FD\u4E3A\u7A7A" }],
+          isError: true
+        };
+      }
+      try {
+        const result = rpc ? await rpc.start({
+          taskId,
+          key,
+          name: asString3(args.name) || void 0,
+          cwd,
+          command,
+          readyPattern: asString3(args.readyPattern) || void 0,
+          portsHint: asPorts(args.portsHint)
+        }) : await (async () => {
+          throw new Error("Terminal RPC \u4E0D\u53EF\u7528\uFF08\u9700\u5728 connect \u4E3B\u8FDB\u7A0B\uFF09");
+        })();
+        return JSON.stringify(result, null, 2);
+      } catch (err) {
+        const detail = err instanceof Error ? err.message : String(err);
+        return {
+          content: [{ type: "text", text: `\u542F\u52A8\u7EC8\u7AEF\u5931\u8D25: ${detail}` }],
+          isError: true
+        };
+      }
+    }
+  };
+  const StopWebIdeTerminal = {
+    description: "Stop a WebIDE terminal and kill its process tree. Soft-terminates (status EXITED, record kept).",
+    inputSchema: {
+      type: "object",
+      properties: {
+        key: { type: "string", description: "Terminal key" },
+        terminalId: { type: "string", description: "Server terminal id" }
+      }
+    },
+    execute: async (args) => {
+      const key = asString3(args.key) || void 0;
+      const terminalId = asString3(args.terminalId) || void 0;
+      if (!key && !terminalId) {
+        return {
+          content: [{ type: "text", text: "\u9700\u8981 key \u6216 terminalId" }],
+          isError: true
+        };
+      }
+      try {
+        const result = rpc ? await rpc.stop({ taskId, key, terminalId }) : await (async () => {
+          throw new Error("Terminal RPC \u4E0D\u53EF\u7528\uFF08\u9700\u5728 connect \u4E3B\u8FDB\u7A0B\uFF09");
+        })();
+        return JSON.stringify(result, null, 2);
+      } catch (err) {
+        const detail = err instanceof Error ? err.message : String(err);
+        return {
+          content: [{ type: "text", text: `\u505C\u6B62\u7EC8\u7AEF\u5931\u8D25: ${detail}` }],
+          isError: true
+        };
+      }
+    }
+  };
+  const StopAllWebIdeTerminals = {
+    description: "Stop all living WebIDE terminals for the current task (kill process trees). Use before re-running local dev to avoid port conflicts. Soft-terminates records.",
+    inputSchema: {
+      type: "object",
+      properties: {}
+    },
+    execute: async () => {
+      try {
+        const result = rpc ? await rpc.stopAll({ taskId }) : await (async () => {
+          throw new Error("Terminal RPC \u4E0D\u53EF\u7528\uFF08\u9700\u5728 connect \u4E3B\u8FDB\u7A0B\uFF09");
+        })();
+        return JSON.stringify(result, null, 2);
+      } catch (err) {
+        const detail = err instanceof Error ? err.message : String(err);
+        return {
+          content: [{ type: "text", text: `\u5168\u90E8\u505C\u6B62\u5931\u8D25: ${detail}` }],
+          isError: true
+        };
+      }
+    }
+  };
+  const ListWebIdeTerminals = {
+    description: "List living WebIDE terminals for the current task (STARTING/RUNNING/READY/STOPPING only). Does NOT include EXITED/FAILED. Returns id, key, status, pid, ports.",
+    inputSchema: {
+      type: "object",
+      properties: {}
+    },
+    execute: async () => {
+      try {
+        if (rpc) {
+          const result2 = await rpc.list({ taskId });
+          return JSON.stringify(result2, null, 2);
+        }
+        const api = createApmApiClient(cfg);
+        const result = await api.cli.webideListTerminals({ taskId });
+        return JSON.stringify(result, null, 2);
+      } catch (err) {
+        const detail = err instanceof Error ? err.message : String(err);
+        return {
+          content: [{ type: "text", text: `\u5217\u51FA\u7EC8\u7AEF\u5931\u8D25: ${detail}` }],
+          isError: true
+        };
+      }
+    }
+  };
+  return {
+    StartWebIdeTerminal,
+    StopWebIdeTerminal,
+    StopAllWebIdeTerminals,
+    ListWebIdeTerminals
+  };
+}
+
 // 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
@@ -6977,6 +7795,21 @@ function createCursorCustomTools(cfg, messageId, options) {
       cfg,
       taskId: options.taskId
     });
+    tools.MergeWebIdePullRequests = createMergeWebIdePullRequestsTool({
+      cfg,
+      taskId: options.taskId
+    });
+    if (options.workdir) {
+      Object.assign(
+        tools,
+        createWebIdeTerminalTools({
+          cfg,
+          taskId: options.taskId,
+          workdir: options.workdir,
+          rpc: options.terminalRpc
+        })
+      );
+    }
   }
   return tools;
 }
@@ -7100,7 +7933,9 @@ async function runCursorAgent(cfg, ctx, options) {
     appendMessageContent: options?.appendMessageContent,
     askQuestionExecute: options?.askQuestionExecute,
     enableWebIdePlanTools: options?.enableWebIdePlanTools,
-    taskId: options?.taskId
+    taskId: options?.taskId,
+    workdir,
+    terminalRpc: options?.terminalRpc
   });
   const enableSandbox = Boolean(options?.enableSandbox);
   let prompt = withPlanModeToolHint(ctx.prompt, ctx.mode);
@@ -7242,6 +8077,7 @@ async function runCursorAgent(cfg, ctx, options) {
 }
 
 // src/commands/connect/ensure-message-reply.ts
+init_client();
 var DEFAULT_REPLY = "\u4EFB\u52A1\u5DF2\u5B8C\u6210\u3002";
 function resolveMessageReplyFallback(fallback) {
   for (const candidate of [
@@ -7385,6 +8221,7 @@ function createRunSlotPool(maxConcurrent = DEFAULT_MAX_CONCURRENT, options = {})
 }
 
 // src/commands/connect/webide-worker-pool.ts
+init_webide_terminal_registry();
 import { Worker } from "node:worker_threads";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 import { dirname as dirname7, join as join20 } from "node:path";
@@ -7396,23 +8233,78 @@ function spawnWebIdeMessageWorker(cfg, msg) {
   const worker = new Worker(workerFile, {
     workerData: { cfg, msg }
   });
+  const registry = getWebIdeTerminalRegistry(cfg);
   let resolveDone;
   const done = new Promise((resolve7) => {
     resolveDone = resolve7;
   });
-  worker.on(
-    "message",
-    (m) => {
-      if (m?.type === "done" || m?.type === "error") {
-        if (m.type === "error") {
-          console.error(
-            `[apm] webide worker error messageId=${m.messageId}: ${m.error}`
-          );
+  worker.on("message", (m) => {
+    if (m?.type === "terminal-rpc") {
+      const rpc = m;
+      void (async () => {
+        try {
+          let result;
+          if (rpc.op === "start") {
+            result = await registry.start({
+              taskId: String(rpc.args.taskId ?? msg.taskId),
+              key: String(rpc.args.key ?? ""),
+              name: typeof rpc.args.name === "string" ? rpc.args.name : void 0,
+              cwd: String(rpc.args.cwd ?? msg.workdir),
+              command: String(rpc.args.command ?? ""),
+              readyPattern: typeof rpc.args.readyPattern === "string" ? rpc.args.readyPattern : void 0,
+              portsHint: Array.isArray(rpc.args.portsHint) ? rpc.args.portsHint : void 0
+            });
+          } else if (rpc.op === "stop") {
+            const terminalId = typeof rpc.args.terminalId === "string" ? rpc.args.terminalId : void 0;
+            const key = typeof rpc.args.key === "string" ? rpc.args.key : void 0;
+            const taskId = String(rpc.args.taskId ?? msg.taskId);
+            let id = terminalId;
+            if (!id && key) {
+              const local = registry.listLocal(taskId).find((t) => t.key === key);
+              id = local?.id;
+            }
+            if (!id) {
+              throw new Error("\u672A\u627E\u5230\u7EC8\u7AEF");
+            }
+            result = await registry.stop(id, { reason: "ai-stop" });
+          } else if (rpc.op === "stopAll") {
+            result = await registry.stopAllForTask(
+              String(rpc.args.taskId ?? msg.taskId),
+              "ai-stop-all"
+            );
+          } else {
+            result = {
+              terminals: registry.listLocal(
+                String(rpc.args.taskId ?? msg.taskId)
+              )
+            };
+          }
+          worker.postMessage({
+            type: "terminal-rpc-result",
+            id: rpc.id,
+            ok: true,
+            result
+          });
+        } catch (err) {
+          worker.postMessage({
+            type: "terminal-rpc-result",
+            id: rpc.id,
+            ok: false,
+            error: err instanceof Error ? err.message : String(err)
+          });
         }
-        void worker.terminate().finally(() => resolveDone());
+      })();
+      return;
+    }
+    if (m?.type === "done" || m?.type === "error") {
+      if (m.type === "error") {
+        console.error(
+          `[apm] webide worker error messageId=${m.messageId}: ${m.error}`
+        );
       }
+      void worker.terminate().finally(() => resolveDone());
     }
-  );
+  });
   worker.on("error", (err) => {
     console.error("[apm] webide worker crashed:", err);
     resolveDone();
@@ -7689,6 +8581,11 @@ function attachWsHandlers(ws, ctx, onOpen) {
       const msg2 = validated.data;
       const task2 = (async () => {
         const workdir = requireRemoteWorkdir(msg2.workdir);
+        const { getWebIdeTerminalRegistry: getWebIdeTerminalRegistry2 } = await Promise.resolve().then(() => (init_webide_terminal_registry(), webide_terminal_registry_exports));
+        await getWebIdeTerminalRegistry2(cfg).stopAllForTask(
+          msg2.taskId,
+          "cache-cleanup"
+        );
         cleanWebIdeWorkspaceCache(msg2.taskId, workdir);
       })();
       activeTasks.add(task2);
@@ -7697,6 +8594,21 @@ function attachWsHandlers(ws, ctx, onOpen) {
       });
       return;
     }
+    if (validated.data.type === "webide-terminal-stop") {
+      const msg2 = validated.data;
+      const task2 = (async () => {
+        const { getWebIdeTerminalRegistry: getWebIdeTerminalRegistry2 } = await Promise.resolve().then(() => (init_webide_terminal_registry(), webide_terminal_registry_exports));
+        await getWebIdeTerminalRegistry2(cfg).stop(msg2.terminalId, {
+          pid: msg2.pid,
+          reason: "web-stop"
+        });
+      })();
+      activeTasks.add(task2);
+      void task2.finally(() => {
+        activeTasks.delete(task2);
+      });
+      return;
+    }
     if (validated.data.type === "webide-message") {
       const msg2 = validated.data;
       const perMessageController2 = new AbortController();
@@ -7961,6 +8873,10 @@ async function runConnect(options) {
   }
 }
 
+// src/commands/create-pr.ts
+init_client();
+init_config();
+
 // src/commands/create-pr-errors.ts
 import { ApiError as ApiError2 } from "listpage-http";
 function extractMessage(error) {
@@ -8088,6 +9004,8 @@ async function runCreatePr(options) {
 }
 
 // src/commands/deploy/deploy-tracking.ts
+init_client();
+init_config();
 function normalizeDeployEnvironment(env) {
   const normalized = env.trim().toLowerCase();
   if (normalized === "test") return "TEST";
@@ -8757,6 +9675,7 @@ function registerDeployBackendCommands(program) {
 // src/commands/deploy/frontend.ts
 import { copyFile, readdir as readdir3, stat } from "node:fs/promises";
 import path17 from "node:path";
+init_minio();
 function artifactObjectKey(namePrefix, branchSegment, relativePath) {
   const base = sanitizeRelativePath(namePrefix);
   const rel = sanitizeRelativePath(relativePath);
@@ -8934,6 +9853,7 @@ function registerDeployFrontendCommands(program) {
 
 // src/commands/deploy/sftp.ts
 import path18 from "node:path";
+init_minio();
 function registerDeploySftpCommands(program) {
   program.command("deploy-sftp").description(
     "\u5C06\u6307\u5B9A\u76EE\u5F55\u538B\u7F29\u4E3A zip \u540E\u901A\u8FC7 SFTP \u4E0A\u4F20\u5230\u8FDC\u7A0B\u670D\u52A1\u5668\uFF08\u8FDE\u63A5\u4FE1\u606F\u89C1 apm.config.json wisdomDeploy\uFF09"