{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "initialize",
  "params": {
    "processId": 12345,
    "clientInfo": {
      "name": "VS Code",
      "version": "1.85.0"
    },
    "locale": "zh-cn",
    "rootPath": "/home/user/my-project",
    "rootUri": "file:///home/user/my-project",
    "capabilities": {
      "textDocument": {
        "completion": {
          "completionItem": {
            "snippetSupport": true,
            "commitCharactersSupport": true,
            "documentationFormat": ["markdown", "plaintext"],
            "deprecatedSupport": true,
            "preselectSupport": true
          },
          "completionItemKind": {
            "valueSet": [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25]
          }
        },
        "hover": {
          "contentFormat": ["markdown", "plaintext"]
        },
        "definition": {
          "dynamicRegistration": true,
          "linkSupport": true
        },
        "publishDiagnostics": {
          "relatedInformation": true,
          "tagSupport": {
            "valueSet": [1, 2]
          }
        }
      },
      "workspace": {
        "workspaceFolders": true,
        "didChangeConfiguration": {
          "dynamicRegistration": true
        },
        "didChangeWatchedFiles": {
          "dynamicRegistration": true
        }
      }
    },
    "workspaceFolders": [
      {
        "uri": "file:///home/user/my-project",
        "name": "my-project"
      }
    ]
  }
}

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "capabilities": {
      "textDocumentSync": {
        "openClose": true,
        "change": 2,
        "willSave": false,
        "willSaveWaitUntil": false,
        "save": {
          "includeText": false
        }
      },
      "completionProvider": {
        "resolveProvider": true,
        "triggerCharacters": [".", ":", "@", "/"],
        "allCommitCharacters": ["(", ",", ";"]
      },
      "hoverProvider": true,
      "definitionProvider": true,
      "referencesProvider": true,
      "documentSymbolProvider": true,
      "workspaceSymbolProvider": true,
      "codeActionProvider": {
        "codeActionKinds": ["quickfix", "refactor"],
        "resolveProvider": true
      },
      "documentFormattingProvider": true,
      "renameProvider": {
        "prepareProvider": true
      }
    },
    "serverInfo": {
      "name": "my-language-server",
      "version": "1.0.0"
    }
  }
}

// Server 在 InitializeResult 中声明
capabilities: {
  hoverProvider: true,
  definitionProvider: true,
  completionProvider: {
    triggerCharacters: ["."],
    resolveProvider: true,
  },
}

// Server 在运行时注册新能力
connection.sendRequest("client/registerCapability", {
  registrations: [
    {
      id: "format-on-save",
      method: "textDocument/willSaveWaitUntil",
      registerOptions: {
        documentSelector: [{ scheme: "file", language: "python" }],
      },
    },
  ],
});

// Server 注销能力
connection.sendRequest("client/unregisterCapability", {
  unregisterations: [
    {
      id: "format-on-save",
      method: "textDocument/willSaveWaitUntil",
    },
  ],
});

{
  "jsonrpc": "2.0",
  "method": "initialized",
  "params": {}
}

// Client 发送取消通知
{
  "jsonrpc": "2.0",
  "method": "$/cancelRequest",
  "params": {
    "id": 42  // 要取消的请求 ID
  }
}

import { CancellationTokenSource } from "vscode-jsonrpc";

// 跟踪活跃的请求
const activeRequests = new Map<number, CancellationTokenSource>();

connection.onRequest("textDocument/completion", async (params, token) => {
  const requestId = /* 从 context 获取 */ 0;
  const cts = new CancellationTokenSource();
  activeRequests.set(requestId, cts);

  token.onCancellationRequested(() => {
    cts.cancel();
    activeRequests.delete(requestId);
  });

  try {
    return await computeCompletions(params, cts.token);
  } finally {
    activeRequests.delete(requestId);
  }
});

// Server 端报告进度
connection.onRequest("textDocument/references", async (params) => {
  // 创建进度令牌
  const progressToken = await connection.sendRequest("window/workDoneProgress/create", {
    token: "references-search",
  });

  // 发送进度通知
  connection.sendProgress("window/workDoneProgress", "references-search", {
    kind: "begin",
    title: "Searching references...",
    percentage: 0,
  });

  // ... 搜索过程中更新进度
  connection.sendProgress("window/workDoneProgress", "references-search", {
    kind: "report",
    message: "Searching in src/",
    percentage: 50,
  });

  // 完成
  connection.sendProgress("window/workDoneProgress", "references-search", {
    kind: "end",
    message: "Done",
  });

  return results;
});

{
  "jsonrpc": "2.0",
  "id": 2,
  "method": "shutdown",
  "params": null
}

{
  "jsonrpc": "2.0",
  "id": 2,
  "result": null
}

{
  "jsonrpc": "2.0",
  "method": "exit",
  "params": null
}

let isShuttingDown = false;

connection.onRequest("shutdown", async () => {
  isShuttingDown = true;

  // 清理资源
  await flushDiagnostics();
  closeAllDocuments();
  clearCaches();

  return null; // shutdown 响应结果必须是 null
});

connection.onNotification("exit", () => {
  // 退出码：0 = 正常关闭（shutdown 已调用），1 = 异常退出
  process.exit(isShuttingDown ? 0 : 1);
});

// 在 shutdown 之后拒绝新的请求
connection.onRequest(async (method) => {
  if (isShuttingDown) {
    throw new rpc.ResponseError(
      rpc.ErrorCodes.InvalidRequest,
      "Server is shutting down"
    );
  }
});

const clientProcessId = params.processId;

if (clientProcessId !== null) {
  // 定期检查 Client 进程是否存活
  const checkInterval = setInterval(() => {
    try {
      process.kill(clientProcessId, 0); // signal 0 = 检测进程是否存在
    } catch {
      // Client 进程已退出，Server 也应该退出
      clearInterval(checkInterval);
      process.exit(1);
    }
  }, 5000);
}

class LSPClientWithReconnect {
  private maxRetries = 5;
  private retryDelay = 1000; // ms

  async connect(): Promise<void> {
    for (let attempt = 0; attempt < this.maxRetries; attempt++) {
      try {
        await this.startServer();
        await this.sendInitialize();
        console.log("Connected to LSP server");
        return;
      } catch (err) {
        console.warn(`Connection attempt ${attempt + 1} failed:`, err);
        await this.sleep(this.retryDelay * (attempt + 1));
      }
    }
    throw new Error("Failed to connect after max retries");
  }

  private async startServer(): Promise<void> {
    // 启动 Server 进程
    this.serverProcess = spawn("node", ["server.js"], {
      stdio: ["pipe", "pipe", "pipe"],
    });

    // 监听进程退出，触发重连
    this.serverProcess.on("exit", (code) => {
      if (code !== 0) {
        console.warn("Server exited unexpectedly, reconnecting...");
        setTimeout(() => this.connect(), 1000);
      }
    });
  }

  private sleep(ms: number): Promise<void> {
    return new Promise((resolve) => setTimeout(resolve, ms));
  }
}

import {
  createMessageConnection,
  StreamMessageReader,
  StreamMessageWriter,
} from "vscode-jsonrpc/node";
import { spawn } from "child_process";

async function main() {
  // 1. 启动 Server 进程
  const server = spawn("my-lsp-server", [], {
    stdio: ["pipe", "pipe", "pipe"],
  });

  // 2. 创建连接
  const connection = createMessageConnection(
    new StreamMessageReader(server.stdout),
    new StreamMessageWriter(server.stdin)
  );

  // 3. 注册日志监听
  connection.onNotification("window/logMessage", (params) => {
    console.log(`[Server ${params.type}] ${params.message}`);
  });

  // 4. 启动连接
  connection.listen();

  // 5. 初始化
  const initResult = await connection.sendRequest("initialize", {
    processId: process.pid,
    rootUri: "file:///home/user/project",
    capabilities: {},
  });
  console.log("Server capabilities:", initResult.capabilities);

  // 6. 发送 initialized 通知
  connection.sendNotification("initialized", {});

  // 7. 正常使用...
  // await connection.sendRequest("textDocument/completion", ...);

  // 8. 优雅关闭
  await connection.sendRequest("shutdown", null);
  connection.sendNotification("exit", {});

  // 9. 等待进程退出
  server.on("exit", () => {
    console.log("Server exited");
    connection.dispose();
  });
}

main().catch(console.error);