draftgo-cli 3.0.53 → 3.0.54

package/README.md

@@ -101,6 +101,8 @@ draftgo mcp test                # 验证 initialize、tools/list、项目/正文
 draftgo mcp serve               # 启动 stdio -> 远端 Streamable HTTP bridge
 ```
 
+`mcp serve` 会保留远端 `Mcp-Session-Id`。服务重启或 session 过期后，它会自动重新 initialize，并只重试一次被明确拒绝为 session 无效的当前请求；普通工具失败、超时和 5xx 不会自动重试。`mcp test` 使用独立的新连接，只证明当前配置能够建立新 session，不能直接证明宿主此前持有的 session 仍有效。
+
 `setup` 不传 target 时自动检测当前项目的宿主。可用 `--target codex,cursor` 传入多个目标。
 
 当前 MCP 宿主支持：

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "draftgo-cli",
-  "version": "3.0.53",
+  "version": "3.0.54",
   "description": "Install and manage the DraftGo skill across AI coding agents (Claude Code, Codex, Cursor, Windsurf, Antigravity, Copilot, Gemini, Kiro).",
   "bin": {
     "draftgo": "bin/draftgo.js"

package/resources/skill/manifest.json

@@ -2,7 +2,7 @@
   "schema_version": "1.0",
   "id": "draftgo",
   "name": "DraftGo 开发助手",
-  "version": "3.0.53",
+  "version": "3.0.54",
   "entry": "SKILL.md",
   "description": "以 Skill/reference 任务路由、MCP 实时发现、长正文 checkout/commit、统一验证和完成日志为边界的 DraftGo 工作流。",
   "license": "MIT",

package/resources/skill/references/mcp.md

@@ -84,7 +84,9 @@ draftgo mcp serve
 - `setup` 写入项目级宿主配置，只替换 `draftgo` MCP 条目并保留其他配置。
 - `status` 检查配置是否存在、格式是否有效，以及是否误写了凭据或远端 URL。
 - `test` 从 `.draftgo/config.json` 读取连接，验证 initialize、tools/list、三类正文 resource_list，以及 db_meta 的 api_search、api_describe 和只读 api_call。
-- `serve` 启动 stdio bridge，把宿主请求代理到当前项目配置的远端 Streamable HTTP `/mcp`。
+- `serve` 启动 stdio bridge，把宿主请求代理到当前项目配置的远端 Streamable HTTP `/mcp`。远端重启或 session 过期后，bridge 会清除旧 `Mcp-Session-Id`、重新 initialize，并对被明确拒绝为 session 无效的当前请求重试一次；普通超时、服务端错误和工具错误不会自动重试。
+
+`draftgo mcp test` 每次使用独立的新连接，因此它证明当前 server、SAT 和协议可以建立新 session，不代表宿主已持有的旧 session 仍然有效。宿主工具报告 session 失效但 `mcp test` 成功时，bridge 应自动恢复；若恢复仍失败，再检查远端日志、代理头传递和服务可用性。
 
 `draftgo connect` 保存并验证 server/SAT、探测 `/mcp` 和关键工具，并可提示宿主 setup；`--server` 表示基础地址，完整 MCP endpoint 使用 `--mcp-url` 显式传入。它不下载业务资源，
 也不创建 pages、navigation、docs、db_meta 等本地镜像。底座仍在开发或暂不可达时，报告诊断结果即可，

package/src/mcp/client.js

@@ -65,6 +65,44 @@ class McpRpcError extends Error {
   }
 }
 
+const SESSION_INVALID_CODES = new Set([
+  -32002,
+  'SESSION_EXPIRED',
+  'SESSION_NOT_FOUND',
+  'MCP_SESSION_EXPIRED',
+  'MCP_SESSION_NOT_FOUND',
+]);
+
+function isSessionInvalidError(error) {
+  if (!error) return false;
+  if (Number(error.status) === 404) return true;
+  const code = error.code != null
+    ? error.code
+    : error.rpc && error.rpc.error && error.rpc.error.code;
+  if (SESSION_INVALID_CODES.has(code)) return true;
+  const message = String(error.message
+    || error.rpc && error.rpc.error && error.rpc.error.message
+    || '');
+  return /\b(?:mcp\s+)?session(?:\s+id)?\s+(?:was\s+)?(?:not\s+found|expired|invalid|unknown|lost)\b/i.test(message)
+    || /\b(?:server|mcp)\s+(?:is\s+)?(?:not initialized|uninitialized)\b/i.test(message)
+    || /\binitialize first\b/i.test(message);
+}
+
+function requestIdKeys(message) {
+  const messages = Array.isArray(message) ? message : [message];
+  return new Set(messages
+    .filter((item) => isObject(item) && typeof item.method === 'string' && item.id != null)
+    .map((item) => `${typeof item.id}:${JSON.stringify(item.id)}`));
+}
+
+function sessionInvalidResponse(message, expectedIds) {
+  const messages = Array.isArray(message) ? message : [message];
+  return messages.find((item) => isObject(item)
+    && item.error
+    && expectedIds.has(`${typeof item.id}:${JSON.stringify(item.id)}`)
+    && isSessionInvalidError(item.error)) || null;
+}
+
 function diagnosticNextCursor(result) {
   const value = diagnosticData(result);
   if (!value || typeof value !== 'object' || Array.isArray(value)) return null;
@@ -154,6 +192,9 @@ class DraftGoMcpClient {
     this.sessionId = null;
     this.protocolVersion = options.protocolVersion || DEFAULT_PROTOCOL_VERSION;
     this.nextId = 1;
+    this.sessionGeneration = 0;
+    this.sessionRecovery = null;
+    this.sessionRecoveryCount = 0;
     this.onMessage = typeof options.onMessage === 'function' ? options.onMessage : null;
   }
 
@@ -163,28 +204,65 @@ class DraftGoMcpClient {
     }
 
     const initialize = findInitializeRequest(message);
+    const internalRecovery = options._sessionRecoveryInternal === true;
+    if (!initialize && !internalRecovery && this.sessionRecovery) {
+      await this.sessionRecovery;
+    }
+    if (initialize) this.sessionId = null;
     const requestedVersion = initialize
       && initialize.params
       && initialize.params.protocolVersion;
     const delivered = [];
+    const expectedIds = requestIdKeys(message);
+    const attemptedSessionId = initialize ? null : this.sessionId;
+    const attemptedGeneration = this.sessionGeneration;
+    const canRecover = !initialize
+      && !internalRecovery
+      && options._sessionRecoveryAttempted !== true
+      && attemptedSessionId != null;
+    let suppressedSessionError = null;
 
     try {
       await postJsonRpc(this.config, message, {
         signal: options.signal,
         timeoutMs: options.timeoutMs,
-        sessionId: this.sessionId,
+        sessionId: attemptedSessionId,
         protocolVersion: requestedVersion || this.protocolVersion,
-        onSession: (sessionId) => { this.sessionId = sessionId; },
+        onSession: (sessionId) => {
+          if (initialize || (this.sessionGeneration === attemptedGeneration
+              && this.sessionId === attemptedSessionId)) {
+            this.sessionId = sessionId;
+          }
+        },
         onMessage: (remoteMessage) => {
           const safe = redactValue(remoteMessage, this.secrets);
           delivered.push(safe);
+          const invalid = canRecover && sessionInvalidResponse(safe, expectedIds);
+          if (invalid) {
+            suppressedSessionError = invalid;
+            return;
+          }
+          if (options._suppressCallbacks === true) return;
           if (this.onMessage) this.onMessage(safe);
           if (typeof options.onMessage === 'function') options.onMessage(safe);
         },
       });
+      if (suppressedSessionError) {
+        const remoteError = suppressedSessionError.error;
+        const error = new McpRpcError(
+          remoteError.message || `MCP error ${remoteError.code}`,
+          { code: remoteError.code, data: remoteError.data, id: suppressedSessionError.id },
+        );
+        error.rpc = suppressedSessionError;
+        throw error;
+      }
     } catch (error) {
       if (error && error.rpc) error.rpc = redactValue(error.rpc, this.secrets);
       if (error && error.message) error.message = redactText(error.message, this.secrets);
+      if (canRecover && isSessionInvalidError(error)) {
+        await this.recoverSession(attemptedSessionId, attemptedGeneration, options);
+        return this.forward(message, { ...options, _sessionRecoveryAttempted: true });
+      }
       throw error;
     }
 
@@ -196,6 +274,54 @@ class DraftGoMcpClient {
     return delivered;
   }
 
+  async recoverSession(failedSessionId, failedGeneration, options = {}) {
+    if (this.sessionGeneration !== failedGeneration) return;
+    if (this.sessionId != null && this.sessionId !== failedSessionId) return;
+    if (this.sessionRecovery) return this.sessionRecovery;
+
+    const recoveryNumber = this.sessionRecoveryCount + 1;
+    this.sessionId = null;
+    const recovery = (async () => {
+      if (typeof options.onSessionRecovery === 'function') {
+        options.onSessionRecovery('started', { attempt: recoveryNumber });
+      }
+      try {
+        await this.initialize({
+          id: `draftgo-session-recovery-${recoveryNumber}`,
+          protocolVersion: this.protocolVersion,
+          timeoutMs: options.timeoutMs,
+          signal: options.signal,
+          _sessionRecoveryInternal: true,
+          _suppressCallbacks: true,
+        });
+        this.sessionRecoveryCount = recoveryNumber;
+        if (typeof options.onSessionRecovery === 'function') {
+          options.onSessionRecovery('succeeded', { attempt: recoveryNumber });
+        }
+      } catch (error) {
+        this.sessionId = null;
+        if (typeof options.onSessionRecovery === 'function') {
+          options.onSessionRecovery('failed', { attempt: recoveryNumber });
+        }
+        const message = redactText(error && error.message ? error.message : error, this.secrets);
+        const wrapped = new McpRpcError(`DraftGo MCP session recovery failed: ${message}`, {
+          code: error && error.code != null ? error.code : -32000,
+          data: error && error.data,
+        });
+        wrapped.status = Number(error && error.status) || 0;
+        wrapped.sessionRecovery = true;
+        wrapped.cause = error;
+        throw wrapped;
+      }
+    })();
+    this.sessionRecovery = recovery;
+    try {
+      await recovery;
+    } finally {
+      if (this.sessionRecovery === recovery) this.sessionRecovery = null;
+    }
+  }
+
   async request(method, params, options = {}) {
     const id = options.id == null ? this.nextId++ : options.id;
     const message = { jsonrpc: '2.0', id, method };
@@ -249,6 +375,7 @@ class DraftGoMcpClient {
       throw error;
     }
     if (typeof options.onStage === 'function') options.onStage('initialized', 'succeeded');
+    this.sessionGeneration += 1;
     return result;
   }
 
@@ -425,6 +552,7 @@ class DraftGoMcpClient {
       initialized,
       protocolVersion: this.protocolVersion,
       sessionId: this.sessionId,
+      sessionRecoveries: this.sessionRecoveryCount,
       tools,
       testedTool: tested[0].name,
       toolResult: tested[0].result,
@@ -457,6 +585,7 @@ module.exports = {
   diagnosticData,
   diagnosticNextCursor,
   findDBMetaListOperation,
+  isSessionInvalidError,
   redactValue,
   testConnection,
   callTool,