ai-project-manage-cli 7.1.12 → 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,
@@ -360,211 +1351,17 @@ async function copyTemplateFiles(targetDir, workdir = resolveWorkdirPath()) {
   for (const name of entries) {
     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"
-    }),
-    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"
-    })
+  for (const subdir of WORKSPACE_TEMPLATE_SUBDIRS) {
+    mkdirSync2(toFsPath(join2(resolvedTarget, subdir)), { recursive: true });
   }
-};
-
-// 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]
-  });
+  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";
@@ -769,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) {
@@ -832,6 +1630,8 @@ ${diagnostic ?? ""}
 }
 
 // src/repository-project-documents-sync.ts
+init_client();
+init_config();
 import {
   existsSync as existsSync2,
   readdirSync as readdirSync2,
@@ -1097,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) {
@@ -1158,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();
@@ -1281,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",
@@ -1603,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";
@@ -1713,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";
 
@@ -2135,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) {
@@ -2398,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) {
@@ -2519,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) {
@@ -2538,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) {
@@ -2566,6 +3381,7 @@ async function runAppendMessage(options) {
 }
 
 // src/commands/update-message-status.ts
+init_client();
 var VALID_STATUSES = [
   "CREATED",
   "QUEUED",
@@ -2594,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) {
@@ -2777,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") {
@@ -2801,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";
 
@@ -3054,366 +3903,119 @@ function resolveWisdomBackendPackOnlyFromApmConfig(cfg) {
     mavenLocalRepoSourceDetail: mavenLocalRepo.sourceDetail,
     mode: resolveWisdomDeployMode(w.mode)
   };
-}
-function resolveWisdomBackendDeployFromApmConfig(cfg) {
-  const projectName = reqTopLevelName(cfg);
-  const w = cfg.wisdomDeploy ?? {};
-  const h = cfg.healthCheck ?? {};
-  const jarPath = req(w.jarPath, "jarPath", "wisdomDeploy").trim();
-  const remoteAppDir = posixDirname(jarPath);
-  const healthPort = Number(req(h.port, "port", "healthCheck"));
-  const healthTimeout = Number(req(h.timeout, "timeout", "healthCheck"));
-  if (!Number.isFinite(healthPort) || !Number.isInteger(healthPort) || healthPort < 1) {
-    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;
+}
+function resolveWisdomBackendDeployFromApmConfig(cfg) {
+  const projectName = reqTopLevelName(cfg);
+  const w = cfg.wisdomDeploy ?? {};
+  const h = cfg.healthCheck ?? {};
+  const jarPath = req(w.jarPath, "jarPath", "wisdomDeploy").trim();
+  const remoteAppDir = posixDirname(jarPath);
+  const healthPort = Number(req(h.port, "port", "healthCheck"));
+  const healthTimeout = Number(req(h.timeout, "timeout", "healthCheck"));
+  if (!Number.isFinite(healthPort) || !Number.isInteger(healthPort) || healthPort < 1) {
+    console.error("apm.config.json \u4E2D healthCheck.port \u987B\u4E3A\u6B63\u6574\u6570");
+    process.exit(1);
   }
-  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,
@@ -4548,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 {
@@ -4616,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) {
@@ -4704,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,
@@ -5703,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);
@@ -5910,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 = [];
@@ -6638,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;
@@ -6806,16 +7418,17 @@ ${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 after conflicts are resolved locally and pushed. Call once with no arguments. Do NOT call if conflicts contradict the task requirements \u2014 report the conflict and fail instead.",
+    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: you have checked each repo, resolved mergeable conflicts consistently with requirements, and pushed. If conflicts contradict requirements, do not call this tool."
+          description: "Must be true to confirm you intend to merge this task's open PRs now."
         }
       },
       required: ["confirmedConflictFree"]
@@ -6823,7 +7436,7 @@ function createMergeWebIdePullRequestsTool(options) {
     execute: async (args) => {
       if (args.confirmedConflictFree !== true) {
         throw new Error(
-          "MergeWebIdePullRequests \u8981\u6C42 confirmedConflictFree=true\u3002\u82E5\u5B58\u5728\u4E0E\u9700\u6C42\u76F8\u6096\u7684\u51B2\u7A81\uFF0C\u8BF7\u52FF\u8C03\u7528\u672C\u5DE5\u5177\uFF0C\u7528 AppendMessage \u8BF4\u660E\u5E76\u5931\u8D25\u7ED3\u675F\u3002"
+          "MergeWebIdePullRequests \u8981\u6C42 confirmedConflictFree=true\u3002"
         );
       }
       const api = createApmApiClient(cfg);
@@ -6835,6 +7448,7 @@ function createMergeWebIdePullRequestsTool(options) {
 }
 
 // src/commands/connect/webide-plan-tools.ts
+init_client();
 function asString(value) {
   return typeof value === "string" ? value.trim() : "";
 }
@@ -6904,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() : "";
 }
@@ -6988,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
@@ -7025,6 +7799,17 @@ function createCursorCustomTools(cfg, messageId, options) {
       cfg,
       taskId: options.taskId
     });
+    if (options.workdir) {
+      Object.assign(
+        tools,
+        createWebIdeTerminalTools({
+          cfg,
+          taskId: options.taskId,
+          workdir: options.workdir,
+          rpc: options.terminalRpc
+        })
+      );
+    }
   }
   return tools;
 }
@@ -7148,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);
@@ -7290,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 [
@@ -7433,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";
@@ -7444,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();
@@ -7737,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);
@@ -7745,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();
@@ -8009,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) {
@@ -8136,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";
@@ -8805,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);
@@ -8982,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"