dsh-git-push 2.15.1 → 2.15.3

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -132,6 +132,7 @@ export const TOOL_REGISTRY = [
132
132
  { flag: 'waitVisible', type: 'boolean', desc: '发布后等待 registry 可见(默认 false:上传成功即为成功,可见延迟是已知现象;true 时每分钟查一次、最多 5 分钟)' },
133
133
  { flag: 'json', type: 'boolean', desc: 'JSON 输出(CLI 用;与其它工具同口径)' },
134
134
  { flag: 'skipSmoke', type: 'boolean', desc: '跳过发布前冒烟(默认跑:pack→干净目录安装→import 公开面→解析依赖;关掉会失去“装得上”这层门禁)' },
135
+ { flag: 'localPreview', type: 'boolean', desc: '本地 registry 彩排(默认关):真实 publish 到本机 registry 再从它安装并加载公开面,不写公网;分钟级,发版前建议开一次' },
135
136
  ],
136
137
  },
137
138
  {
@@ -294,6 +294,8 @@ async function callNpmPublishJob(args = {}, jobs, exec, log, env = {}, cfg = {})
294
294
  otp: args.otp || '',
295
295
  // 发布前冒烟默认开;慢/离线环境可关(关掉就等于放弃「装得上」这一层门禁)
296
296
  skipSmoke: args.skipSmoke === true || args.noSmoke === true,
297
+ // 本地 registry 彩排:走真 publish/install 协议但不写公网(分钟级,发版前建议开一次)
298
+ localPreview: args.localPreview === true,
297
299
  confirm: args.confirm === true,
298
300
  // 可选:发布后等待 registry 可见(默认不等——上传成功即为成功,可见延迟是已知现象)
299
301
  waitVisible: args.waitVisible === true,
@@ -0,0 +1,218 @@
1
+ /**
2
+ * 零依赖本地 npm registry —— 把本机当"npm 网站",用于**发布前彩排**:
3
+ * publish → install → 加载 全链路真跑一遍,公网零痕迹(不写 registry.npmjs.org)。
4
+ *
5
+ * 为什么自己实现而不装 verdaccio:registry 的发布/安装协议面很小(三条路由),
6
+ * 而 verdaccio 是一个带配置与存储布局的独立服务。这里只要能回答三件事:
7
+ * ① `npm publish` 能不能成功(含版本冲突 403、dist-tags 写入)
8
+ * ② `npm install <pkg>` 能不能装上(packument + tarball 两个请求)
9
+ * ③ 装完能不能加载(由调用方继续 import 公开面)
10
+ * 零依赖 → 随仓库走、不污染 node_modules。
11
+ *
12
+ * 与「发布前冒烟(lib/npm/smoke.js)」的分工:
13
+ * · 冒烟 = pack → 本地装 tarball → import(4 秒级,验**包内容**);
14
+ * · 本地 registry = publish → 从 registry 装 → import(分钟级,验**真实发布/安装语义**:
15
+ * 版本冲突、dist-tags、exports、依赖解析全走真路径)。
16
+ *
17
+ * 两个实现坑(实测踩过,勿改回去):
18
+ * ① 调用方与 server 同进程时**必须用异步 spawn**,不能 spawnSync —— 后者阻塞事件循环,
19
+ * npm 发的 PUT 没人应答、这边又在等 npm 退出 ⇒ 死锁(实测 publish 卡 10 分钟)。
20
+ * ② npm publish 需要在 `--userconfig` 指定的 npmrc 里写该 registry 的认证令牌;
21
+ * 只在环境变量里给令牌,客户端仍报 ENEEDAUTH。
22
+ */
23
+ import { createServer } from 'node:http';
24
+ import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from 'node:fs';
25
+ import { join } from 'node:path';
26
+ import { tmpdir } from 'node:os';
27
+ import { randomBytes } from 'node:crypto';
28
+ import { gunzipSync } from 'node:zlib';
29
+ import { spawn } from 'node:child_process';
30
+
31
+ const UPSTREAM = 'https://registry.npmjs.org';
32
+
33
+ /** 异步执行命令(见文件头坑①:绝不能用 spawnSync)。 */
34
+ function run(cmd, args, { cwd, env, timeoutMs = 300000 } = {}) {
35
+ return new Promise((resolve) => {
36
+ const child = spawn(cmd, args, { cwd, env, stdio: ['ignore', 'pipe', 'pipe'] });
37
+ let out = '';
38
+ let err = '';
39
+ child.stdout.on('data', (d) => { out += String(d); });
40
+ child.stderr.on('data', (d) => { err += String(d); });
41
+ const timer = setTimeout(() => { try { child.kill('SIGTERM'); } catch { /* 已退出 */ } }, timeoutMs);
42
+ child.on('close', (code, signal) => { clearTimeout(timer); resolve({ code, signal, out, err }); });
43
+ });
44
+ }
45
+
46
+ /**
47
+ * 起一个本地 registry。
48
+ * @param {{storeDir?:string, port?:number}} o
49
+ * @returns {Promise<{url:string, port:number, storeDir:string, packuments:Map, tarballs:Map, close:Function}>}
50
+ */
51
+ export async function startLocalRegistry({ storeDir, port = 0 } = {}) {
52
+ const dir = storeDir || mkdtempSync(join(tmpdir(), 'dshgp-registry-'));
53
+ mkdirSync(dir, { recursive: true });
54
+ const packuments = new Map(); // name → { 'dist-tags', versions }
55
+ const tarballs = new Map(); // `${name}/${file}` → Buffer
56
+
57
+ const json = (res, code, obj) => {
58
+ const body = JSON.stringify(obj);
59
+ res.writeHead(code, { 'content-type': 'application/json', 'content-length': Buffer.byteLength(body) });
60
+ res.end(body);
61
+ };
62
+
63
+ const readBody = (req) => new Promise((resolve, reject) => {
64
+ const chunks = [];
65
+ req.on('data', (c) => chunks.push(c));
66
+ req.on('end', () => {
67
+ let buf = Buffer.concat(chunks);
68
+ if (req.headers['content-encoding'] === 'gzip') { try { buf = gunzipSync(buf); } catch { /* 原样解析 */ } }
69
+ resolve(buf);
70
+ });
71
+ req.on('error', reject);
72
+ });
73
+
74
+ /** 未知包透传公有 registry(当镜像用;否则装依赖时会 404)。 */
75
+ async function proxyToUpstream(req, res) {
76
+ const ctrl = new AbortController();
77
+ const timer = setTimeout(() => ctrl.abort(), 30000);
78
+ try {
79
+ const upstream = await fetch(`${UPSTREAM}${req.url}`, {
80
+ headers: { accept: String(req.headers.accept || '*/*'), 'user-agent': 'dsh-git-push-local-registry' },
81
+ signal: ctrl.signal,
82
+ });
83
+ const buf = Buffer.from(await upstream.arrayBuffer());
84
+ res.writeHead(upstream.status, {
85
+ 'content-type': upstream.headers.get('content-type') || 'application/octet-stream',
86
+ 'content-length': buf.length,
87
+ });
88
+ return res.end(buf);
89
+ } catch (e) {
90
+ return json(res, 502, { error: `upstream proxy failed: ${String(e?.message || e).slice(0, 200)}` });
91
+ } finally { clearTimeout(timer); }
92
+ }
93
+
94
+ const server = createServer(async (req, res) => {
95
+ const path = decodeURIComponent(new URL(req.url, 'http://127.0.0.1').pathname);
96
+ if (path === '/-/ping') return json(res, 200, { ok: true });
97
+
98
+ const tarMatch = /^\/(.+)\/-\/([^/]+)$/.exec(path);
99
+ if (tarMatch && req.method === 'GET') {
100
+ const buf = tarballs.get(`${tarMatch[1]}/${tarMatch[2]}`);
101
+ if (!buf) { res.writeHead(404); return res.end('not found'); }
102
+ res.writeHead(200, { 'content-type': 'application/octet-stream', 'content-length': buf.length });
103
+ return res.end(buf);
104
+ }
105
+
106
+ const name = path.replace(/^\//, '');
107
+ if (!name) { res.writeHead(404); return res.end('not found'); }
108
+
109
+ if (req.method === 'GET') {
110
+ const doc = packuments.get(name);
111
+ if (doc) return json(res, 200, doc);
112
+ return proxyToUpstream(req, res);
113
+ }
114
+
115
+ if (req.method === 'PUT') {
116
+ let body;
117
+ try { body = JSON.parse((await readBody(req)).toString('utf8')); } catch (e) {
118
+ return json(res, 400, { error: `bad body: ${e.message}` });
119
+ }
120
+ const versions = body.versions || {};
121
+ const vids = Object.keys(versions);
122
+ if (!vids.length) return json(res, 400, { error: 'no versions' });
123
+ const existing = packuments.get(name) || { 'dist-tags': {}, versions: {} };
124
+ for (const v of vids) {
125
+ // 与真 registry 语义一致:同版本号不允许重复发布
126
+ if (existing.versions[v]) return json(res, 403, { error: `cannot publish over existing version ${v}` });
127
+ }
128
+ const atts = Object.entries(body._attachments || {});
129
+ for (const [file, att] of atts) {
130
+ tarballs.set(`${name}/${file}`, Buffer.from(String(att?.data || ''), 'base64'));
131
+ }
132
+ const merged = {
133
+ name,
134
+ 'dist-tags': { ...(existing['dist-tags'] || {}), ...(body['dist-tags'] || {}) },
135
+ versions: { ...existing.versions, ...versions },
136
+ };
137
+ for (const v of Object.keys(merged.versions)) {
138
+ const file = `${name}-${v}.tgz`;
139
+ if (!tarballs.has(`${name}/${file}`) && atts.length) tarballs.set(`${name}/${file}`, tarballs.get(`${name}/${atts[0][0]}`));
140
+ merged.versions[v] = {
141
+ ...merged.versions[v],
142
+ dist: { ...(merged.versions[v].dist || {}), tarball: `http://127.0.0.1:${server.address().port}/${name}/-/${file}` },
143
+ };
144
+ }
145
+ packuments.set(name, merged);
146
+ return json(res, 201, { ok: true, name, versions: Object.keys(merged.versions) });
147
+ }
148
+
149
+ res.writeHead(405); res.end('method not allowed');
150
+ });
151
+
152
+ await new Promise((resolve, reject) => {
153
+ server.once('error', reject);
154
+ server.listen(port, '127.0.0.1', resolve);
155
+ });
156
+ const actualPort = server.address().port;
157
+ return {
158
+ url: `http://127.0.0.1:${actualPort}`,
159
+ port: actualPort,
160
+ storeDir: dir,
161
+ packuments,
162
+ tarballs,
163
+ close: () => new Promise((resolve) => {
164
+ server.close(() => { try { rmSync(dir, { recursive: true, force: true }); } catch { /* 清理失败不影响结论 */ } resolve(); });
165
+ }),
166
+ };
167
+ }
168
+
169
+ /**
170
+ * 发布彩排:publish → install → 加载公开面。
171
+ * @param {{dir:string, tag?:string, packageName?:string, entrySpecs?:string[], timeoutMs?:number}} o
172
+ * @returns {Promise<{ok:boolean, steps:object[], failures:string[], packument?:object}>}
173
+ */
174
+ export async function runLocalPreview({ dir, tag = 'beta', packageName = '', entrySpecs = [], timeoutMs = 300000 } = {}) {
175
+ const steps = [];
176
+ const failures = [];
177
+ const reg = await startLocalRegistry();
178
+ let work = '';
179
+ try {
180
+ // 令牌在运行期随机生成:不在仓库里出现任何"像凭据"的字面量
181
+ const token = `local-${randomBytes(8).toString('hex')}`;
182
+ work = mkdtempSync(join(tmpdir(), 'dshgp-preview-'));
183
+ const npmrc = join(work, '.npmrc');
184
+ writeFileSync(npmrc, `registry=${reg.url}/\n//127.0.0.1:${reg.port}/:_authToken=${token}\n`, 'utf8');
185
+ const common = ['--registry', `${reg.url}/`, '--userconfig', npmrc];
186
+ const env = { ...process.env, npm_config_userconfig: npmrc, npm_config_registry: `${reg.url}/` };
187
+
188
+ const pub = await run('npm', ['publish', ...common, '--tag', tag], { cwd: dir, env, timeoutMs });
189
+ steps.push({ step: 'publish', ok: pub.code === 0 });
190
+ if (pub.code !== 0) { failures.push(`npm publish(本地)失败:${(pub.err || pub.out).slice(-400)}`); return { ok: false, steps, failures }; }
191
+
192
+ const name = packageName || (reg.packuments.keys().next().value || '');
193
+ const doc = reg.packuments.get(name);
194
+ steps.push({ step: 'packument', ok: !!doc, distTags: doc && doc['dist-tags'] });
195
+ if (!doc) { failures.push('本地 registry 没有拿到 packument'); return { ok: false, steps, failures }; }
196
+
197
+ const consumer = join(work, 'consumer');
198
+ mkdirSync(consumer, { recursive: true });
199
+ writeFileSync(join(consumer, 'package.json'), JSON.stringify({ name: 'preview-consumer', private: true, version: '0.0.0' }, null, 2), 'utf8');
200
+ const inst = await run('npm', ['install', `${name}@${tag}`, ...common, '--no-audit', '--no-fund'], { cwd: consumer, env, timeoutMs });
201
+ steps.push({ step: 'install', ok: inst.code === 0 });
202
+ if (inst.code !== 0) { failures.push(`npm install(本地 registry)失败:${(inst.err || inst.out).slice(-400)}`); return { ok: false, steps, failures }; }
203
+
204
+ if (entrySpecs.length) {
205
+ const script = `for (const s of ${JSON.stringify(entrySpecs)}) { await import(s); }\nconsole.log('ok');\n`;
206
+ const probe = await run(process.execPath, ['--input-type=module', '-e', script], { cwd: consumer, env, timeoutMs });
207
+ steps.push({ step: 'import', ok: probe.code === 0, specs: entrySpecs });
208
+ if (probe.code !== 0) failures.push(`从本地 registry 安装后加载失败:${(probe.err || '').slice(0, 400)}`);
209
+ }
210
+ return { ok: failures.length === 0, steps, failures, packument: { name, distTags: doc['dist-tags'], versions: Object.keys(doc.versions || {}) } };
211
+ } catch (e) {
212
+ failures.push(`本地彩排异常:${String(e?.message || e).slice(0, 300)}`);
213
+ return { ok: false, steps, failures };
214
+ } finally {
215
+ await reg.close();
216
+ if (work) { try { rmSync(work, { recursive: true, force: true }); } catch { /* 忽略 */ } }
217
+ }
218
+ }
@@ -13,7 +13,8 @@ import { join } from 'node:path';
13
13
  import { credentialsDir, readNpmToken } from '../core/credentials.js';
14
14
  import { DEFAULT_REGISTRY, NPM_TIMEOUT_MS, normalizeRegistry, runNpm } from './registry.js';
15
15
  import { npmArgs, writeNpmrc } from './npmrc.js';
16
- import { smokeTestPackage } from './smoke.js';
16
+ import { smokeTestPackage, entrySpecsOf, isBrowserEntry } from './smoke.js';
17
+ import { runLocalPreview } from './local-registry.js';
17
18
 
18
19
  export const PUBLISH_LOG_FILE = 'npm-publish.log';
19
20
  export const PUBLISH_TIMEOUT_MS = 300_000;
@@ -121,6 +122,9 @@ export async function publishPackage({
121
122
  // 发布前冒烟(默认开):pack → 干净目录装 → import 公开面 → 解析依赖。
122
123
  // 干跑只给「会打进哪些文件」,不证明「装上能不能用」——这类问题只能在真装一次时暴露。
123
124
  skipSmoke = false,
125
+ // 本地 registry 彩排(默认关):publish → install → 加载 全走真 registry 协议,但不写公网。
126
+ // 比冒烟更接近真实,代价是分钟级;适合发版前手动开一次。
127
+ localPreview = false,
124
128
  // 可选:发布成功后等待 registry 可见。默认 false —— 上传成功即为成功(可见延迟是已知现象)
125
129
  waitVisible = false,
126
130
  } = {}) {
@@ -164,6 +168,24 @@ export async function publishPackage({
164
168
  }
165
169
  }
166
170
 
171
+ // 体检⑤:本地 registry 彩排(可选)——真 publish 到本地 registry 再装回来加载。
172
+ let preview = null;
173
+ if (localPreview) {
174
+ const pkgForPreview = JSON.parse(readFileSync(join(info.dir, 'package.json'), 'utf8'));
175
+ const specs = entrySpecsOf(pkgForPreview).filter((sp) => {
176
+ const key = sp === pkgForPreview.name ? '.' : `./${sp.slice(String(pkgForPreview.name).length + 1)}`;
177
+ return !isBrowserEntry(key);
178
+ });
179
+ preview = await runLocalPreview({ dir: info.dir, tag: tg, packageName: info.name, entrySpecs: specs, timeoutMs });
180
+ if (!preview.ok) {
181
+ return {
182
+ ok: false, blocked: 'local-preview-failed', name: info.name, version: info.version,
183
+ error: `本地 registry 彩排不通过:${(preview.failures || []).slice(0, 3).join(';')}`,
184
+ localPreview: preview,
185
+ };
186
+ }
187
+ }
188
+
167
189
  const rc = writeNpmrc({ workspaceRoot, registry: reg, token });
168
190
  if (!rc.ok) return { ok: false, error: rc.error || 'npmrc 写入失败' };
169
191
  const args = ['publish', ...npmArgs({ npmrcFile: rc.file, registry: reg }), '--tag', tg];
@@ -201,6 +223,8 @@ export async function publishPackage({
201
223
  tarball: pack.filename,
202
224
  // 发布前冒烟结果(装了没、公开面能不能 import、依赖闭包全不全)
203
225
  smoke: smoke ? { ok: smoke.ok, tgz: smoke.tgz, bytes: smoke.bytes, entries: smoke.entries, deps: smoke.deps, failures: smoke.failures } : null,
226
+ // 本地 registry 彩排结果(publish→install→import 全走真协议,不写公网)
227
+ localPreview: preview ? { ok: preview.ok, steps: preview.steps, packument: preview.packument } : null,
204
228
  published: !dryRun && !!r.ok, // 成功判定:npm 上传成功即为成功(不要求 registry 已可见)
205
229
  // 附加信息(不影响 published):registry 是否已能看到新版本;发布延迟(几分钟)是已知现象
206
230
  visible,
package/lib/self/index.js CHANGED
@@ -9,7 +9,7 @@
9
9
  */
10
10
 
11
11
 
12
- export const VERSION = '2.15.1'; // 2.15.1:npm_publish 增加**发布前冒烟**(默认执行)。干跑只回答「哪些文件会进包」,不回答「装上能不能用」——我们踩过的两类坑都在那之后:依赖漏声明/子路径依赖缺失(js-yaml、tree-sitter-wasms/out/*.wasm)、exports 收窄后内部路径 import 直接 ERR_PACKAGE_PATH_NOT_EXPORTED。现在发布前会真 npm pack → 干净目录 npm i <tgz> → 按 exports 公开面逐个 import → 校验依赖是否真被装进来,失败即拦(blocked: smoke-failed),回执带 smoke 明细;skipSmoke:true 可关(不建议)。浏览器端入口(./client)在 Node 里必然 window is not defined,标为 browserEntries 跳过而非判失败。历史:2.15.0 采集快路径 + 钩子探针 + 改名工具。
12
+ export const VERSION = '2.15.3'; // 2.15.3:本地 registry 接成 npm_publish 选项(localPreview)。registry 实现从脚本提到 lib/npm/local-registry.js(脚本只做 CLI 壳),并可由发布流程直接调用:publish → packument 校验 → 从本地 registry 安装 → 加载公开面,失败即拦(blocked: local-preview-failed)。与冒烟的分工:冒烟验包内容(秒级),本地彩排验真实发布/安装语义(分钟级、不写公网)。历史:2.15.2 本地 registry 脚本。
13
13
  // 实测后果:该目录有 package.json ⇒ npm 去打包整棵 DSH 树、输出 2.1MB > spawnSync 默认 maxBuffer 1MB ⇒ ENOBUFS(npm_publish 的体检与真发全部失败);
14
14
  // 该目录没有 package.json 时报 ENOENT。现 publish 的两个调用点显式传 cwd=目标包目录,并给 runNpm 加 16MB maxBuffer。
15
15
  // 2.8.3:文案修正——「零改动 / 无新提交」明确为**正常成功路径**(注入用法、工具描述、README、skill 同批改),并修 job 输出自相矛盾(cleanSkipCommit 路径补 committed:false,不再显示「已提交,未推送」)
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "dsh-git-push",
3
- "version": "2.15.1",
3
+ "version": "2.15.3",
4
4
  "description": "DSH git 自动提交推送插件——统一函数入口架构(规则/审计/git/自身/侧边栏/评分/豁免/上下文/HTTP/测试十大总入口)",
5
5
  "type": "module",
6
6
  "main": "lib/index.js",
@@ -0,0 +1,37 @@
1
+ #!/usr/bin/env node
2
+ /**
3
+ * 本地 npm registry 的命令行入口(实现在 `lib/npm/local-registry.js`)。
4
+ *
5
+ * 用途:把本机当"npm 网站"做**发布彩排**——publish → install → 加载公开面,全程不写公共 registry。
6
+ *
7
+ * 用法:
8
+ * node scripts/local-registry.mjs --selftest # 一条命令跑完整彩排(推荐)
9
+ * node scripts/local-registry.mjs --port=4873 # 前台起服务(Ctrl-C 结束)
10
+ *
11
+ * 要真发到公网请用 `npm_publish`(含发布前冒烟);这里只做彩排,结束即清理临时目录。
12
+ */
13
+ import { fileURLToPath } from 'node:url';
14
+ import { startLocalRegistry, runLocalPreview } from '../lib/npm/local-registry.js';
15
+
16
+ const repo = fileURLToPath(new URL('..', import.meta.url));
17
+ const args = process.argv.slice(2);
18
+
19
+ if (args.includes('--selftest')) {
20
+ const r = await runLocalPreview({
21
+ dir: repo,
22
+ tag: 'beta',
23
+ entrySpecs: ['dsh-git-push', 'dsh-git-push/audit'],
24
+ });
25
+ for (const s of r.steps) console.log(` ${s.ok ? 'OK ' : 'FAIL'} ${s.step}${s.distTags ? ` → dist-tags ${JSON.stringify(s.distTags)}` : ''}`);
26
+ if (r.failures.length) console.log('失败:\n' + r.failures.map((f) => ` - ${f}`).join('\n'));
27
+ else console.log(`彩排通过(${r.packument?.name}@${r.packument?.distTags?.beta || '?'});临时目录已清理,公网零痕迹`);
28
+ process.exit(r.ok ? 0 : 1);
29
+ } else {
30
+ const portArg = args.find((a) => a.startsWith('--port='));
31
+ const port = Number(portArg ? portArg.split('=')[1] : 4873);
32
+ const reg = await startLocalRegistry({ port });
33
+ console.log(`本地 npm registry: ${reg.url}(Ctrl-C 结束)`);
34
+ const stop = async () => { await reg.close(); process.exit(0); };
35
+ process.on('SIGINT', stop);
36
+ process.on('SIGTERM', stop);
37
+ }