@jingyi0605/codingns 0.8.0 → 0.8.1

package/vendor/node-pty-fork/scripts/apply-patches.mjs

@@ -0,0 +1,341 @@
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const packageRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+
+function detectEol(text) {
+  return text.includes("\r\n") ? "\r\n" : "\n";
+}
+
+function normalize(text) {
+  return text.replace(/\r\n/g, "\n");
+}
+
+function applyExactReplacements(filePath, replacements) {
+  const original = fs.readFileSync(filePath, "utf8");
+  const eol = detectEol(original);
+  let normalized = normalize(original);
+
+  for (const replacement of replacements) {
+    if (normalized.includes(replacement.to)) {
+      console.log(`[codingns-node-pty] 已是目标内容，跳过：${path.relative(packageRoot, filePath)} (${replacement.label})`);
+      continue;
+    }
+    if (!normalized.includes(replacement.from)) {
+      throw new Error(`未找到预期片段：${filePath}${"\n"}${replacement.label}`);
+    }
+    normalized = normalized.replace(replacement.from, replacement.to);
+  }
+
+  fs.writeFileSync(filePath, normalized.replace(/\n/g, eol), "utf8");
+  console.log(`[codingns-node-pty] 已写回 fork 覆盖：${path.relative(packageRoot, filePath)}`);
+}
+
+applyExactReplacements(path.join(packageRoot, "src", "win", "conpty.cc"), [
+  {
+    label: "conpty typedef guard",
+    from: `// Taken from the RS5 Windows SDK, but redefined here in case we're targeting <= 17134
+#ifndef PROC_THREAD_ATTRIBUTE_PSEUDOCONSOLE
+#define PROC_THREAD_ATTRIBUTE_PSEUDOCONSOLE \\
+  ProcThreadAttributeValue(22, FALSE, TRUE, FALSE)
+
+typedef VOID* HPCON;
+typedef HRESULT (__stdcall *PFNCREATEPSEUDOCONSOLE)(COORD c, HANDLE hIn, HANDLE hOut, DWORD dwFlags, HPCON* phpcon);
+typedef HRESULT (__stdcall *PFNRESIZEPSEUDOCONSOLE)(HPCON hpc, COORD newSize);
+typedef HRESULT (__stdcall *PFNCLEARPSEUDOCONSOLE)(HPCON hpc);
+typedef void (__stdcall *PFNCLOSEPSEUDOCONSOLE)(HPCON hpc);
+
+#endif
+`,
+    to: `// Taken from the RS5 Windows SDK, but redefined here in case we're targeting <= 17134.
+#ifndef PROC_THREAD_ATTRIBUTE_PSEUDOCONSOLE
+#define PROC_THREAD_ATTRIBUTE_PSEUDOCONSOLE \\
+  ProcThreadAttributeValue(22, FALSE, TRUE, FALSE)
+#endif
+
+#ifndef _HPCON_DEFINED
+typedef VOID* HPCON;
+#endif
+
+typedef HRESULT (__stdcall *PFNCREATEPSEUDOCONSOLE)(COORD c, HANDLE hIn, HANDLE hOut, DWORD dwFlags, HPCON* phpcon);
+typedef HRESULT (__stdcall *PFNRESIZEPSEUDOCONSOLE)(HPCON hpc, COORD newSize);
+typedef HRESULT (__stdcall *PFNCLEARPSEUDOCONSOLE)(HPCON hpc);
+typedef void (__stdcall *PFNCLOSEPSEUDOCONSOLE)(HPCON hpc);
+`
+  }
+]);
+
+applyExactReplacements(path.join(packageRoot, "src", "win", "winpty.cc"), [
+  {
+    label: "winpty PtyStartProcess full sync",
+    from: `static NAN_METHOD(PtyStartProcess) {
+  Nan::HandleScope scope;
+
+  if (info.Length() != 7 ||
+      !info[0]->IsString() ||
+      !info[1]->IsString() ||
+      !info[2]->IsArray() ||
+      !info[3]->IsString() ||
+      !info[4]->IsNumber() ||
+      !info[5]->IsNumber() ||
+      !info[6]->IsBoolean()) {
+    Nan::ThrowError("Usage: pty.startProcess(file, cmdline, env, cwd, cols, rows, debug)");
+    return;
+  }
+
+  std::stringstream why;
+
+  const wchar_t *filename = path_util::to_wstring(Nan::Utf8String(info[0]));
+  const wchar_t *cmdline = path_util::to_wstring(Nan::Utf8String(info[1]));
+  const wchar_t *cwd = path_util::to_wstring(Nan::Utf8String(info[3]));
+
+  // create environment block
+  std::wstring env;
+  const v8::Local<v8::Array> envValues = v8::Local<v8::Array>::Cast(info[2]);
+  if (!envValues.IsEmpty()) {
+
+    std::wstringstream envBlock;
+
+    for(uint32_t i = 0; i < envValues->Length(); i++) {
+      std::wstring envValue(path_util::to_wstring(Nan::Utf8String(Nan::Get(envValues, i).ToLocalChecked())));
+      envBlock << envValue << L'\\0';
+    }
+
+    env = envBlock.str();
+  }
+
+  // use environment 'Path' variable to determine location of
+  // the relative path that we have recieved (e.g cmd.exe)
+  std::wstring shellpath;
+  if (::PathIsRelativeW(filename)) {
+    shellpath = path_util::get_shell_path(filename);
+  } else {
+    shellpath = filename;
+  }
+
+  std::string shellpath_(shellpath.begin(), shellpath.end());
+
+  if (shellpath.empty() || !path_util::file_exists(shellpath)) {
+    why << "File not found: " << shellpath_;
+    Nan::ThrowError(why.str().c_str());
+    goto cleanup;
+  }
+
+  int cols = info[4]->Int32Value(Nan::GetCurrentContext()).FromJust();
+  int rows = info[5]->Int32Value(Nan::GetCurrentContext()).FromJust();
+  bool debug = Nan::To<bool>(info[6]).FromJust();
+
+  // Enable/disable debugging
+  SetEnvironmentVariable(WINPTY_DBG_VARIABLE, debug ? "1" : NULL); // NULL = deletes variable
+
+  // Create winpty config
+  winpty_error_ptr_t error_ptr = nullptr;
+  winpty_config_t* winpty_config = winpty_config_new(0, &error_ptr);
+  if (winpty_config == nullptr) {
+    throw_winpty_error("Error creating WinPTY config", error_ptr);
+    goto cleanup;
+  }
+  winpty_error_free(error_ptr);
+
+  // Set pty size on config
+  winpty_config_set_initial_size(winpty_config, cols, rows);
+
+  // Start the pty agent
+  winpty_t *pc = winpty_open(winpty_config, &error_ptr);
+  winpty_config_free(winpty_config);
+  if (pc == nullptr) {
+    throw_winpty_error("Error launching WinPTY agent", error_ptr);
+    goto cleanup;
+  }
+  winpty_error_free(error_ptr);
+
+  // Save pty struct for later use
+  ptyHandles.insert(ptyHandles.end(), pc);
+
+  // Create winpty spawn config
+  winpty_spawn_config_t* config = winpty_spawn_config_new(WINPTY_SPAWN_FLAG_AUTO_SHUTDOWN, shellpath.c_str(), cmdline, cwd, env.c_str(), &error_ptr);
+  if (config == nullptr) {
+    throw_winpty_error("Error creating WinPTY spawn config", error_ptr);
+    goto cleanup;
+  }
+  winpty_error_free(error_ptr);
+
+  // Spawn the new process
+  HANDLE handle = nullptr;
+  BOOL spawnSuccess = winpty_spawn(pc, config, &handle, nullptr, nullptr, &error_ptr);
+  winpty_spawn_config_free(config);
+  if (!spawnSuccess) {
+    throw_winpty_error("Unable to start terminal process", error_ptr);
+    goto cleanup;
+  }
+  winpty_error_free(error_ptr);
+
+  // Set return values
+  v8::Local<v8::Object> marshal = Nan::New<v8::Object>();
+  Nan::Set(marshal, Nan::New<v8::String>("innerPid").ToLocalChecked(), Nan::New<v8::Number>((int)GetProcessId(handle)));
+  Nan::Set(marshal, Nan::New<v8::String>("innerPidHandle").ToLocalChecked(), Nan::New<v8::Number>((int)handle));
+  Nan::Set(marshal, Nan::New<v8::String>("pid").ToLocalChecked(), Nan::New<v8::Number>((int)winpty_agent_process(pc)));
+  Nan::Set(marshal, Nan::New<v8::String>("pty").ToLocalChecked(), Nan::New<v8::Number>(InterlockedIncrement(&ptyCounter)));
+  Nan::Set(marshal, Nan::New<v8::String>("fd").ToLocalChecked(), Nan::New<v8::Number>(-1));
+  {
+    LPCWSTR coninPipeName = winpty_conin_name(pc);
+    std::wstring coninPipeNameWStr(coninPipeName);
+    std::string coninPipeNameStr(coninPipeNameWStr.begin(), coninPipeNameWStr.end());
+    Nan::Set(marshal, Nan::New<v8::String>("conin").ToLocalChecked(), Nan::New<v8::String>(coninPipeNameStr).ToLocalChecked());
+    LPCWSTR conoutPipeName = winpty_conout_name(pc);
+    std::wstring conoutPipeNameWStr(conoutPipeName);
+    std::string conoutPipeNameStr(conoutPipeNameWStr.begin(), conoutPipeNameWStr.end());
+    Nan::Set(marshal, Nan::New<v8::String>("conout").ToLocalChecked(), Nan::New<v8::String>(conoutPipeNameStr).ToLocalChecked());
+  }
+  info.GetReturnValue().Set(marshal);
+
+  goto cleanup;
+
+cleanup:
+  delete filename;
+  delete cmdline;
+  delete cwd;
+}
+`,
+    to: `static NAN_METHOD(PtyStartProcess) {
+  Nan::HandleScope scope;
+
+  std::stringstream why;
+  const wchar_t *filename = nullptr;
+  const wchar_t *cmdline = nullptr;
+  const wchar_t *cwd = nullptr;
+  std::wstring env;
+  int cols = 0;
+  int rows = 0;
+  bool debug = false;
+  winpty_error_ptr_t error_ptr = nullptr;
+  winpty_config_t* winpty_config = nullptr;
+  winpty_t *pc = nullptr;
+  winpty_spawn_config_t* config = nullptr;
+  HANDLE handle = nullptr;
+  BOOL spawnSuccess = FALSE;
+  v8::Local<v8::Object> marshal = Nan::New<v8::Object>();
+
+  if (info.Length() != 7 ||
+      !info[0]->IsString() ||
+      !info[1]->IsString() ||
+      !info[2]->IsArray() ||
+      !info[3]->IsString() ||
+      !info[4]->IsNumber() ||
+      !info[5]->IsNumber() ||
+      !info[6]->IsBoolean()) {
+    Nan::ThrowError("Usage: pty.startProcess(file, cmdline, env, cwd, cols, rows, debug)");
+    return;
+  }
+
+  filename = path_util::to_wstring(Nan::Utf8String(info[0]));
+  cmdline = path_util::to_wstring(Nan::Utf8String(info[1]));
+  cwd = path_util::to_wstring(Nan::Utf8String(info[3]));
+
+  // create environment block
+  const v8::Local<v8::Array> envValues = v8::Local<v8::Array>::Cast(info[2]);
+  if (!envValues.IsEmpty()) {
+
+    std::wstringstream envBlock;
+
+    for(uint32_t i = 0; i < envValues->Length(); i++) {
+      std::wstring envValue(path_util::to_wstring(Nan::Utf8String(Nan::Get(envValues, i).ToLocalChecked())));
+      envBlock << envValue << L'\\0';
+    }
+
+    env = envBlock.str();
+  }
+
+  // use environment 'Path' variable to determine location of
+  // the relative path that we have recieved (e.g cmd.exe)
+  std::wstring shellpath;
+  if (::PathIsRelativeW(filename)) {
+    shellpath = path_util::get_shell_path(filename);
+  } else {
+    shellpath = filename;
+  }
+
+  std::string shellpath_(shellpath.begin(), shellpath.end());
+
+  if (shellpath.empty() || !path_util::file_exists(shellpath)) {
+    why << "File not found: " << shellpath_;
+    Nan::ThrowError(why.str().c_str());
+    goto cleanup;
+  }
+
+  cols = info[4]->Int32Value(Nan::GetCurrentContext()).FromJust();
+  rows = info[5]->Int32Value(Nan::GetCurrentContext()).FromJust();
+  debug = Nan::To<bool>(info[6]).FromJust();
+
+  // Enable/disable debugging
+  SetEnvironmentVariable(WINPTY_DBG_VARIABLE, debug ? "1" : NULL); // NULL = deletes variable
+
+  // Create winpty config
+  winpty_config = winpty_config_new(0, &error_ptr);
+  if (winpty_config == nullptr) {
+    throw_winpty_error("Error creating WinPTY config", error_ptr);
+    goto cleanup;
+  }
+  winpty_error_free(error_ptr);
+
+  // Set pty size on config
+  winpty_config_set_initial_size(winpty_config, cols, rows);
+
+  // Start the pty agent
+  pc = winpty_open(winpty_config, &error_ptr);
+  winpty_config_free(winpty_config);
+  if (pc == nullptr) {
+    throw_winpty_error("Error launching WinPTY agent", error_ptr);
+    goto cleanup;
+  }
+  winpty_error_free(error_ptr);
+
+  // Save pty struct for later use
+  ptyHandles.insert(ptyHandles.end(), pc);
+
+  // Create winpty spawn config
+  config = winpty_spawn_config_new(WINPTY_SPAWN_FLAG_AUTO_SHUTDOWN, shellpath.c_str(), cmdline, cwd, env.c_str(), &error_ptr);
+  if (config == nullptr) {
+    throw_winpty_error("Error creating WinPTY spawn config", error_ptr);
+    goto cleanup;
+  }
+  winpty_error_free(error_ptr);
+
+  // Spawn the new process
+  spawnSuccess = winpty_spawn(pc, config, &handle, nullptr, nullptr, &error_ptr);
+  winpty_spawn_config_free(config);
+  if (!spawnSuccess) {
+    throw_winpty_error("Unable to start terminal process", error_ptr);
+    goto cleanup;
+  }
+  winpty_error_free(error_ptr);
+
+  // Set return values
+  Nan::Set(marshal, Nan::New<v8::String>("innerPid").ToLocalChecked(), Nan::New<v8::Number>((int)GetProcessId(handle)));
+  Nan::Set(marshal, Nan::New<v8::String>("innerPidHandle").ToLocalChecked(), Nan::New<v8::Number>((int)handle));
+  Nan::Set(marshal, Nan::New<v8::String>("pid").ToLocalChecked(), Nan::New<v8::Number>((int)winpty_agent_process(pc)));
+  Nan::Set(marshal, Nan::New<v8::String>("pty").ToLocalChecked(), Nan::New<v8::Number>(InterlockedIncrement(&ptyCounter)));
+  Nan::Set(marshal, Nan::New<v8::String>("fd").ToLocalChecked(), Nan::New<v8::Number>(-1));
+  {
+    LPCWSTR coninPipeName = winpty_conin_name(pc);
+    std::wstring coninPipeNameWStr(coninPipeName);
+    std::string coninPipeNameStr(coninPipeNameWStr.begin(), coninPipeNameWStr.end());
+    Nan::Set(marshal, Nan::New<v8::String>("conin").ToLocalChecked(), Nan::New<v8::String>(coninPipeNameStr).ToLocalChecked());
+    LPCWSTR conoutPipeName = winpty_conout_name(pc);
+    std::wstring conoutPipeNameWStr(conoutPipeName);
+    std::string conoutPipeNameStr(conoutPipeNameWStr.begin(), conoutPipeNameWStr.end());
+    Nan::Set(marshal, Nan::New<v8::String>("conout").ToLocalChecked(), Nan::New<v8::String>(conoutPipeNameStr).ToLocalChecked());
+  }
+  info.GetReturnValue().Set(marshal);
+
+  goto cleanup;
+
+cleanup:
+  delete filename;
+  delete cmdline;
+  delete cwd;
+}
+`
+  }
+]);

package/vendor/node-pty-fork/scripts/fetch-upstream.mjs

@@ -0,0 +1,41 @@
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { pipeline } from "node:stream/promises";
+import { createWriteStream } from "node:fs";
+import { spawnSync } from "node:child_process";
+
+const upstreamTarballUrl =
+  process.env.CODINGNS_NODE_PTY_UPSTREAM_TARBALL ??
+  "https://registry.npmjs.org/node-pty/-/node-pty-1.0.0.tgz";
+
+const packageRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+const vendorDir = path.join(packageRoot, "vendor");
+const downloadDir = path.join(vendorDir, "downloads");
+const extractDir = path.join(vendorDir, "upstream");
+const archivePath = path.join(downloadDir, "node-pty-1.0.0.tgz");
+
+fs.mkdirSync(downloadDir, { recursive: true });
+
+if (!fs.existsSync(archivePath)) {
+  const response = await fetch(upstreamTarballUrl);
+  if (!response.ok || !response.body) {
+    throw new Error(`下载上游 tarball 失败：${upstreamTarballUrl} -> ${response.status} ${response.statusText}`);
+  }
+
+  await pipeline(response.body, createWriteStream(archivePath));
+}
+
+fs.rmSync(extractDir, { recursive: true, force: true });
+fs.mkdirSync(extractDir, { recursive: true });
+
+const tarResult = spawnSync("tar", ["-xzf", archivePath, "-C", extractDir], {
+  stdio: "inherit",
+  shell: process.platform === "win32"
+});
+
+if (tarResult.status !== 0) {
+  process.exit(tarResult.status ?? 1);
+}
+
+console.log(`[codingns-node-pty] 已准备上游源码：${extractDir}`);

package/vendor/node-pty-fork/scripts/install-smoke.cjs

@@ -0,0 +1,59 @@
+"use strict";
+
+const fs = require("node:fs");
+const os = require("node:os");
+const path = require("node:path");
+const { spawnSync } = require("node:child_process");
+
+const packageRoot = path.resolve(__dirname, "..");
+const tarballs = fs.readdirSync(packageRoot).filter((fileName) => fileName.endsWith(".tgz")).sort();
+
+if (tarballs.length === 0) {
+  console.error("[codingns-node-pty] 安装验证失败：当前目录没有 npm pack 产物。");
+  process.exit(1);
+}
+
+const tarballPath = path.join(packageRoot, tarballs[tarballs.length - 1]);
+const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), "codingns-node-pty-smoke-"));
+const installLogPath = path.join(tempRoot, "npm-install.log");
+
+fs.writeFileSync(path.join(tempRoot, "package.json"), JSON.stringify({
+  name: "codingns-node-pty-smoke",
+  private: true
+}, null, 2));
+
+const installResult = spawnSync("npm", ["install", tarballPath, "--ignore-scripts=false"], {
+  cwd: tempRoot,
+  encoding: "utf8",
+  shell: process.platform === "win32"
+});
+
+const combinedOutput = `${installResult.stdout || ""}${installResult.stderr || ""}`;
+fs.writeFileSync(installLogPath, combinedOutput, "utf8");
+
+if (installResult.status !== 0) {
+  process.stderr.write(combinedOutput);
+  console.error(`[codingns-node-pty] 安装验证失败：npm install 返回非 0，日志：${installLogPath}`);
+  process.exit(1);
+}
+
+if (/node-gyp rebuild/i.test(combinedOutput)) {
+  console.error(`[codingns-node-pty] 安装验证失败：npm install 过程中触发了 node-gyp rebuild，日志：${installLogPath}`);
+  process.exit(1);
+}
+
+const moduleRoot = path.join(tempRoot, "node_modules", "@codingns", "node-pty");
+const smokeResult = spawnSync("node", [path.join(moduleRoot, "scripts", "smoke-load.cjs")], {
+  cwd: tempRoot,
+  encoding: "utf8",
+  shell: process.platform === "win32"
+});
+
+if (smokeResult.status !== 0) {
+  process.stderr.write(`${smokeResult.stdout || ""}${smokeResult.stderr || ""}`);
+  console.error("[codingns-node-pty] 安装验证失败：tarball 安装后无法完成最小加载检查。");
+  process.exit(1);
+}
+
+process.stdout.write(smokeResult.stdout || "");
+console.log("[codingns-node-pty] tarball 安装验证通过。");

package/vendor/node-pty-fork/scripts/smoke-load.cjs

@@ -0,0 +1,10 @@
+"use strict";
+
+const mod = require("../lib/index.js");
+
+if (!mod || typeof mod.spawn !== "function") {
+  console.error("[codingns-node-pty] smoke test 失败：未导出 spawn。");
+  process.exit(1);
+}
+
+console.log("[codingns-node-pty] smoke load 通过。");

package/vendor/node-pty-fork/scripts/sync-upstream.mjs

@@ -0,0 +1,29 @@
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const packageRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+const upstreamRoot = path.join(packageRoot, "vendor", "upstream", "package");
+
+const copyTargets = [
+  "binding.gyp",
+  "LICENSE",
+  "lib",
+  "src",
+  "typings",
+  "deps"
+];
+
+for (const target of copyTargets) {
+  const sourcePath = path.join(upstreamRoot, target);
+  const targetPath = path.join(packageRoot, target);
+
+  if (!fs.existsSync(sourcePath)) {
+    throw new Error(`缺少上游路径：${sourcePath}`);
+  }
+
+  fs.rmSync(targetPath, { recursive: true, force: true });
+  fs.cpSync(sourcePath, targetPath, { recursive: true });
+}
+
+console.log("[codingns-node-pty] 已同步上游源码骨架。");

package/vendor/node-pty-fork/scripts/verify-runtime.cjs

@@ -0,0 +1,54 @@
+"use strict";
+
+const fs = require("node:fs");
+const path = require("node:path");
+
+const packageRoot = path.resolve(__dirname, "..");
+const releaseDir = path.join(packageRoot, "build", "Release");
+
+const requiredFiles = [
+  path.join(packageRoot, "lib", "index.js"),
+  path.join(packageRoot, "typings", "node-pty.d.ts"),
+  path.join(packageRoot, "binding.gyp")
+];
+
+const runtimeRequired = [
+  "conpty.node",
+  "conpty_console_list.node",
+  "pty.node",
+  "winpty-agent.exe",
+  "winpty.dll"
+];
+
+if (process.platform !== "win32") {
+  console.log("[codingns-node-pty] 非 win32 环境，跳过运行时校验。");
+  process.exit(0);
+}
+
+if (process.arch !== "x64") {
+  console.error("[codingns-node-pty] 当前仅支持 x64。");
+  process.exit(1);
+}
+
+const nodeMajor = Number((process.versions.node || "").split(".")[0]);
+if (nodeMajor !== 22) {
+  console.error(`[codingns-node-pty] 当前仅支持 Node 22，检测到 ${process.versions.node || "unknown"}。`);
+  process.exit(1);
+}
+
+for (const filePath of requiredFiles) {
+  if (!fs.existsSync(filePath)) {
+    console.error(`[codingns-node-pty] 缺少关键文件：${filePath}`);
+    process.exit(1);
+  }
+}
+
+for (const fileName of runtimeRequired) {
+  const filePath = path.join(releaseDir, fileName);
+  if (!fs.existsSync(filePath)) {
+    console.error(`[codingns-node-pty] 缺少预编译产物：${filePath}`);
+    process.exit(1);
+  }
+}
+
+console.log("[codingns-node-pty] 运行时校验通过。");

package/vendor/node-pty-fork/scripts/verify-runtime.test.cjs

@@ -0,0 +1,22 @@
+"use strict";
+
+const assert = require("node:assert/strict");
+const { spawnSync } = require("node:child_process");
+const path = require("node:path");
+const test = require("node:test");
+
+const scriptPath = path.join(__dirname, "verify-runtime.cjs");
+
+test("非 Windows 环境会跳过 node-pty 运行时校验", () => {
+  const result = spawnSync(process.execPath, [scriptPath], {
+    encoding: "utf8"
+  });
+
+  if (process.platform === "win32") {
+    assert.notEqual(result.status, 0);
+    return;
+  }
+
+  assert.equal(result.status, 0);
+  assert.match(result.stdout, /非 win32 环境，跳过运行时校验/);
+});

package/vendor/node-pty-fork/scripts/verify-tarball.cjs

@@ -0,0 +1,80 @@
+"use strict";
+
+const fs = require("node:fs");
+const os = require("node:os");
+const path = require("node:path");
+const { spawnSync } = require("node:child_process");
+
+const packageRoot = path.resolve(__dirname, "..");
+const tarballs = fs.readdirSync(packageRoot).filter((fileName) => fileName.endsWith(".tgz")).sort();
+
+if (tarballs.length === 0) {
+  console.error("[codingns-node-pty] tarball 校验失败：当前目录没有 npm pack 产物。");
+  process.exit(1);
+}
+
+const tarballPath = path.join(packageRoot, tarballs[tarballs.length - 1]);
+const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), "codingns-node-pty-pack-"));
+
+const extractResult = spawnSync("tar", ["-xzf", tarballPath, "-C", tempRoot], {
+  cwd: packageRoot,
+  encoding: "utf8",
+  shell: process.platform === "win32"
+});
+
+if (extractResult.status !== 0) {
+  process.stderr.write(`${extractResult.stdout || ""}${extractResult.stderr || ""}`);
+  console.error(`[codingns-node-pty] tarball 校验失败：无法解包 ${tarballPath}`);
+  process.exit(1);
+}
+
+const unpackedRoot = path.join(tempRoot, "package");
+const packageJsonPath = path.join(unpackedRoot, "package.json");
+
+if (!fs.existsSync(packageJsonPath)) {
+  console.error("[codingns-node-pty] tarball 校验失败：解包后缺少 package/package.json。");
+  process.exit(1);
+}
+
+const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
+
+if (packageJson.name !== "@codingns/node-pty") {
+  console.error(`[codingns-node-pty] tarball 校验失败：包名不对，检测到 ${packageJson.name || "unknown"}。`);
+  process.exit(1);
+}
+
+if (packageJson.version !== "1.0.0-cns.1") {
+  console.error(`[codingns-node-pty] tarball 校验失败：版本不对，检测到 ${packageJson.version || "unknown"}。`);
+  process.exit(1);
+}
+
+if (packageJson.types !== "./typings/node-pty.d.ts") {
+  console.error(`[codingns-node-pty] tarball 校验失败：types 入口不对，检测到 ${packageJson.types || "unknown"}。`);
+  process.exit(1);
+}
+
+const requiredPaths = [
+  path.join(unpackedRoot, "README.md"),
+  path.join(unpackedRoot, "LICENSE"),
+  path.join(unpackedRoot, "lib", "index.js"),
+  path.join(unpackedRoot, "typings", "node-pty.d.ts"),
+  path.join(unpackedRoot, "binding.gyp"),
+  path.join(unpackedRoot, "scripts", "verify-runtime.cjs"),
+  path.join(unpackedRoot, "scripts", "verify-tarball.cjs"),
+  path.join(unpackedRoot, "scripts", "smoke-load.cjs"),
+  path.join(unpackedRoot, "scripts", "install-smoke.cjs"),
+  path.join(unpackedRoot, "build", "Release", "conpty.node"),
+  path.join(unpackedRoot, "build", "Release", "conpty_console_list.node"),
+  path.join(unpackedRoot, "build", "Release", "pty.node"),
+  path.join(unpackedRoot, "build", "Release", "winpty-agent.exe"),
+  path.join(unpackedRoot, "build", "Release", "winpty.dll")
+];
+
+for (const filePath of requiredPaths) {
+  if (!fs.existsSync(filePath)) {
+    console.error(`[codingns-node-pty] tarball 校验失败：缺少关键文件 ${filePath}`);
+    process.exit(1);
+  }
+}
+
+console.log(`[codingns-node-pty] tarball 校验通过：${path.basename(tarballPath)}`);

package/vendor/node-pty-fork/src/conpty_console_list_agent.ts

@@ -0,0 +1,19 @@
+/**
+ * Copyright (c) 2019, Microsoft Corporation (MIT License).
+ *
+ * This module fetches the console process list for a particular PID. It must be
+ * called from a different process (child_process.fork) as there can only be a
+ * single console attached to a process.
+ */
+
+let getConsoleProcessList: any;
+try {
+  getConsoleProcessList = require('../build/Release/conpty_console_list.node').getConsoleProcessList;
+} catch (err) {
+  getConsoleProcessList = require('../build/Debug/conpty_console_list.node').getConsoleProcessList;
+}
+
+const shellPid = parseInt(process.argv[2], 10);
+const consoleProcessList = getConsoleProcessList(shellPid);
+process.send!({ consoleProcessList });
+process.exit(0);