@git.zone/cli 12.1.1 → 12.3.0
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.
- package/assets/templates/npm/.package.json +1 -1
- package/assets/templates/service/.package.json +1 -1
- package/assets/templates/wcc/.package.json +1 -1
- package/assets/templates/website/.package.json +1 -1
- package/dist_ts/00_commitinfo_data.js +1 -1
- package/dist_ts/helpers.tssea.d.ts +2 -7
- package/dist_ts/helpers.tssea.js +20 -10
- package/dist_ts/helpers.versionsource.d.ts +23 -5
- package/dist_ts/helpers.versionsource.js +115 -37
- package/dist_ts/helpers.workflow.d.ts +60 -17
- package/dist_ts/helpers.workflow.js +156 -51
- package/dist_ts/mod_config/index.js +98 -31
- package/dist_ts/mod_release/classes.releasejournal.d.ts +63 -8
- package/dist_ts/mod_release/classes.releasejournal.js +283 -124
- package/dist_ts/mod_release/helpers.cargorelease.d.ts +4 -3
- package/dist_ts/mod_release/helpers.cargorelease.js +5 -4
- package/dist_ts/mod_release/helpers.fossglobalassets.d.ts +61 -0
- package/dist_ts/mod_release/helpers.fossglobalassets.js +580 -0
- package/dist_ts/mod_release/helpers.giteaassets.d.ts +15 -51
- package/dist_ts/mod_release/helpers.giteaassets.js +40 -507
- package/dist_ts/mod_release/helpers.releaseassets.d.ts +40 -0
- package/dist_ts/mod_release/helpers.releaseassets.js +349 -0
- package/dist_ts/mod_release/helpers.releaseassettransfer.d.ts +67 -0
- package/dist_ts/mod_release/helpers.releaseassettransfer.js +239 -0
- package/dist_ts/mod_release/helpers.releasecheck.js +3 -2
- package/dist_ts/mod_release/helpers.releasepreparation.d.ts +7 -6
- package/dist_ts/mod_release/helpers.releasepreparation.js +34 -7
- package/dist_ts/mod_release/helpers.releasepublication.d.ts +8 -2
- package/dist_ts/mod_release/helpers.releasepublication.js +218 -54
- package/dist_ts/mod_release/helpers.releaseversionsource.d.ts +7 -5
- package/dist_ts/mod_release/helpers.releaseversionsource.js +9 -7
- package/dist_ts/mod_release/index.d.ts +1 -1
- package/dist_ts/mod_release/index.js +109 -68
- package/dist_ts/mod_release/interfaces.fossglobalassets.d.ts +108 -0
- package/dist_ts/mod_release/interfaces.fossglobalassets.js +2 -0
- package/dist_ts/mod_release/interfaces.giteaassets.d.ts +9 -43
- package/dist_ts/mod_release/interfaces.releaseassets.d.ts +68 -0
- package/dist_ts/mod_release/interfaces.releaseassets.js +2 -0
- package/dist_ts/plugins.d.ts +1 -0
- package/dist_ts/plugins.js +1 -1
- package/package.json +3 -2
- package/readme.md +339 -41
- package/ts/00_commitinfo_data.ts +1 -1
- package/ts/helpers.tssea.ts +31 -10
- package/ts/helpers.versionsource.ts +176 -45
- package/ts/helpers.workflow.ts +288 -78
- package/ts/mod_config/index.ts +130 -38
- package/ts/mod_release/classes.releasejournal.ts +499 -180
- package/ts/mod_release/helpers.cargorelease.ts +8 -3
- package/ts/mod_release/helpers.fossglobalassets.ts +886 -0
- package/ts/mod_release/helpers.giteaassets.ts +127 -694
- package/ts/mod_release/helpers.releaseassets.ts +516 -0
- package/ts/mod_release/helpers.releaseassettransfer.ts +339 -0
- package/ts/mod_release/helpers.releasecheck.ts +3 -1
- package/ts/mod_release/helpers.releasepreparation.ts +55 -12
- package/ts/mod_release/helpers.releasepublication.ts +351 -69
- package/ts/mod_release/helpers.releaseversionsource.ts +11 -7
- package/ts/mod_release/index.ts +151 -90
- package/ts/mod_release/interfaces.fossglobalassets.ts +127 -0
- package/ts/mod_release/interfaces.giteaassets.ts +14 -47
- package/ts/mod_release/interfaces.releaseassets.ts +96 -0
- package/ts/plugins.ts +3 -0
|
@@ -0,0 +1,40 @@
|
|
|
1
|
+
import * as plugins from "./mod.plugins.js";
|
|
2
|
+
import type { IPrepareReleaseAssetsOptions, IReleaseAssetDestination, IReleaseAssetTarget, IReleaseFrozenAsset, TReleaseAssetTargetName } from "./interfaces.releaseassets.js";
|
|
3
|
+
export type * from "./interfaces.releaseassets.js";
|
|
4
|
+
/**
|
|
5
|
+
* Every release asset target with what it fixes for the shared machinery: the
|
|
6
|
+
* code host its messages name and the bounds of one release's asset set.
|
|
7
|
+
*/
|
|
8
|
+
export declare const releaseAssetTargets: Readonly<Record<TReleaseAssetTargetName, Readonly<IReleaseAssetTarget>>>;
|
|
9
|
+
/**
|
|
10
|
+
* The destination holds something other than the frozen release or asset.
|
|
11
|
+
* Terminal: the claim/inspect executor records it as a destination conflict.
|
|
12
|
+
*/
|
|
13
|
+
export declare class ReleaseAssetConflictError extends Error {
|
|
14
|
+
constructor(message: string);
|
|
15
|
+
}
|
|
16
|
+
export declare const assertReleaseAssetRecord: (target: TReleaseAssetTargetName, value: unknown) => Record<string, unknown>;
|
|
17
|
+
export declare const assertReleaseAssetTag: (target: TReleaseAssetTargetName, value: string) => void;
|
|
18
|
+
export declare const normalizeReleaseAssetDestination: (target: TReleaseAssetTargetName, value: IReleaseAssetDestination) => IReleaseAssetDestination;
|
|
19
|
+
/**
|
|
20
|
+
* The credential of a release asset target from its configured environment
|
|
21
|
+
* variable. Only the variable's name ever appears in a message.
|
|
22
|
+
*/
|
|
23
|
+
export declare const readReleaseAssetCredential: (target: TReleaseAssetTargetName, tokenEnv: string) => string;
|
|
24
|
+
/** The frozen copy's name in the release record directory, covered by its retention. */
|
|
25
|
+
export declare const releaseAssetFileName: (target: TReleaseAssetTargetName, name: string) => string;
|
|
26
|
+
/** The anonymous download URL by tag and asset name. */
|
|
27
|
+
export declare const releaseAssetPublicUrl: (target: TReleaseAssetTargetName, destination: IReleaseAssetDestination, tag: string, name: string) => string;
|
|
28
|
+
/** Opens a regular file reached without any symlink, read-only. */
|
|
29
|
+
export declare const openReleaseAssetFile: (target: TReleaseAssetTargetName, path: string) => Promise<plugins.fs.FileHandle>;
|
|
30
|
+
export type TReleaseAssetFileHandle = Awaited<ReturnType<typeof openReleaseAssetFile>>;
|
|
31
|
+
/** Hashes the whole open file; its size, hash and timestamps must match the frozen asset. */
|
|
32
|
+
export declare const verifyReleaseAssetFile: (target: TReleaseAssetTargetName, handle: TReleaseAssetFileHandle, asset: IReleaseFrozenAsset) => Promise<void>;
|
|
33
|
+
export declare function assertReleaseFrozenAssets(target: TReleaseAssetTargetName, assets: unknown, destination?: IReleaseAssetDestination, tag?: string): asserts assets is IReleaseFrozenAsset[];
|
|
34
|
+
export declare const validateReleaseAssets: (target: TReleaseAssetTargetName, artifactDirectory: string, assets: IReleaseFrozenAsset[]) => Promise<void>;
|
|
35
|
+
/**
|
|
36
|
+
* Reads the manifest `{schemaVersion: 1, version, assets: [{name, path, size,
|
|
37
|
+
* sha256}]}` and freezes each listed file into the release record directory,
|
|
38
|
+
* proving its bytes before and after the copy.
|
|
39
|
+
*/
|
|
40
|
+
export declare const prepareReleaseAssets: (target: TReleaseAssetTargetName, options: IPrepareReleaseAssetsOptions) => Promise<IReleaseFrozenAsset[]>;
|
|
@@ -0,0 +1,349 @@
|
|
|
1
|
+
import * as plugins from "./mod.plugins.js";
|
|
2
|
+
/**
|
|
3
|
+
* Every release asset target with what it fixes for the shared machinery: the
|
|
4
|
+
* code host its messages name and the bounds of one release's asset set.
|
|
5
|
+
*/
|
|
6
|
+
export const releaseAssetTargets = Object.freeze({
|
|
7
|
+
giteaAssets: Object.freeze({
|
|
8
|
+
label: "Gitea",
|
|
9
|
+
hostAssetNoun: "attachment",
|
|
10
|
+
maximumAssets: 1024,
|
|
11
|
+
maximumAssetBytes: 32 * 1024 * 1024 * 1024,
|
|
12
|
+
}),
|
|
13
|
+
// The code host's bounds: 100 assets per release, each of at most
|
|
14
|
+
// GIT_STORAGE_MAX_RELEASE_ASSET_BYTES (2 GiB by default).
|
|
15
|
+
fossglobalAssets: Object.freeze({
|
|
16
|
+
label: "foss.global",
|
|
17
|
+
hostAssetNoun: "asset",
|
|
18
|
+
maximumAssets: 100,
|
|
19
|
+
maximumAssetBytes: 2 * 1024 * 1024 * 1024,
|
|
20
|
+
}),
|
|
21
|
+
});
|
|
22
|
+
const maximumManifestBytes = 4 * 1024 * 1024;
|
|
23
|
+
const canonicalName = /^[A-Za-z0-9][A-Za-z0-9._-]{0,199}$/;
|
|
24
|
+
const sha256Pattern = /^[a-f0-9]{64}$/;
|
|
25
|
+
/**
|
|
26
|
+
* The destination holds something other than the frozen release or asset.
|
|
27
|
+
* Terminal: the claim/inspect executor records it as a destination conflict.
|
|
28
|
+
*/
|
|
29
|
+
export class ReleaseAssetConflictError extends Error {
|
|
30
|
+
constructor(message) {
|
|
31
|
+
super(message);
|
|
32
|
+
this.name = "ReleaseAssetConflictError";
|
|
33
|
+
}
|
|
34
|
+
}
|
|
35
|
+
const labelOf = (target) => releaseAssetTargets[target].label;
|
|
36
|
+
export const assertReleaseAssetRecord = (target, value) => {
|
|
37
|
+
if (!value || typeof value !== "object" || Array.isArray(value)) {
|
|
38
|
+
throw new Error(`Invalid ${labelOf(target)} asset object.`);
|
|
39
|
+
}
|
|
40
|
+
return value;
|
|
41
|
+
};
|
|
42
|
+
const exactKeys = (target, value, keys) => {
|
|
43
|
+
if (Object.keys(value).sort().join("\0") !== [...keys].sort().join("\0")) {
|
|
44
|
+
throw new Error(`Unexpected ${labelOf(target)} asset manifest fields.`);
|
|
45
|
+
}
|
|
46
|
+
};
|
|
47
|
+
const assertName = (target, value) => {
|
|
48
|
+
if (typeof value !== "string" || !canonicalName.test(value)) {
|
|
49
|
+
throw new Error(`${labelOf(target)} asset names must be canonical single path components.`);
|
|
50
|
+
}
|
|
51
|
+
return value;
|
|
52
|
+
};
|
|
53
|
+
export const assertReleaseAssetTag = (target, value) => {
|
|
54
|
+
if (!canonicalName.test(value) ||
|
|
55
|
+
value.endsWith(".") ||
|
|
56
|
+
value.endsWith(".lock") ||
|
|
57
|
+
value.includes("..")) {
|
|
58
|
+
throw new Error(`${labelOf(target)} asset publication requires a canonical release tag.`);
|
|
59
|
+
}
|
|
60
|
+
};
|
|
61
|
+
const assertSizeAndHash = (target, value) => {
|
|
62
|
+
if (!Number.isSafeInteger(value.size) ||
|
|
63
|
+
value.size < 0 ||
|
|
64
|
+
value.size > releaseAssetTargets[target].maximumAssetBytes ||
|
|
65
|
+
typeof value.sha256 !== "string" ||
|
|
66
|
+
!sha256Pattern.test(value.sha256)) {
|
|
67
|
+
throw new Error(`Invalid ${labelOf(target)} asset size or SHA256.`);
|
|
68
|
+
}
|
|
69
|
+
};
|
|
70
|
+
export const normalizeReleaseAssetDestination = (target, value) => {
|
|
71
|
+
const candidate = assertReleaseAssetRecord(target, value);
|
|
72
|
+
exactKeys(target, candidate, ["apiOrigin", "owner", "repository"]);
|
|
73
|
+
let url;
|
|
74
|
+
try {
|
|
75
|
+
url = new URL(candidate.apiOrigin);
|
|
76
|
+
}
|
|
77
|
+
catch {
|
|
78
|
+
throw new Error(`Invalid ${labelOf(target)} API origin.`);
|
|
79
|
+
}
|
|
80
|
+
if (url.protocol !== "https:" ||
|
|
81
|
+
url.username ||
|
|
82
|
+
url.password ||
|
|
83
|
+
url.search ||
|
|
84
|
+
url.hash ||
|
|
85
|
+
url.pathname !== "/" ||
|
|
86
|
+
![url.origin, `${url.origin}/`].includes(candidate.apiOrigin)) {
|
|
87
|
+
throw new Error(`${labelOf(target)} API origin must be credential-free canonical HTTPS.`);
|
|
88
|
+
}
|
|
89
|
+
return {
|
|
90
|
+
apiOrigin: url.origin,
|
|
91
|
+
owner: assertName(target, candidate.owner),
|
|
92
|
+
repository: assertName(target, candidate.repository),
|
|
93
|
+
};
|
|
94
|
+
};
|
|
95
|
+
/**
|
|
96
|
+
* The credential of a release asset target from its configured environment
|
|
97
|
+
* variable. Only the variable's name ever appears in a message.
|
|
98
|
+
*/
|
|
99
|
+
export const readReleaseAssetCredential = (target, tokenEnv) => {
|
|
100
|
+
const token = process.env[tokenEnv];
|
|
101
|
+
if (!token)
|
|
102
|
+
throw new Error(`${labelOf(target)} assets require the configured credential in ${tokenEnv}.`);
|
|
103
|
+
return token;
|
|
104
|
+
};
|
|
105
|
+
/** The frozen copy's name in the release record directory, covered by its retention. */
|
|
106
|
+
export const releaseAssetFileName = (target, name) => `asset.${plugins.crypto.createHash("sha256").update(assertName(target, name)).digest("hex")}.bin`;
|
|
107
|
+
/** The anonymous download URL by tag and asset name. */
|
|
108
|
+
export const releaseAssetPublicUrl = (target, destination, tag, name) => {
|
|
109
|
+
const normalized = normalizeReleaseAssetDestination(target, destination);
|
|
110
|
+
assertReleaseAssetTag(target, tag);
|
|
111
|
+
return `${normalized.apiOrigin}/${normalized.owner}/${normalized.repository}/releases/download/${encodeURIComponent(tag)}/${assertName(target, name)}`;
|
|
112
|
+
};
|
|
113
|
+
const assertRelativeAssetPath = (value) => {
|
|
114
|
+
if (typeof value !== "string" ||
|
|
115
|
+
value.length > 4096 ||
|
|
116
|
+
value
|
|
117
|
+
.split("/")
|
|
118
|
+
.some((part) => !canonicalName.test(part) ||
|
|
119
|
+
/^(?:node_modules|coverage|secrets?|credentials?|runtime|data|tmp|temp|id_rsa|id_ed25519)(?:\..*)?$/i.test(part) ||
|
|
120
|
+
/\.(?:pem|key|p12|pfx)$/i.test(part))) {
|
|
121
|
+
throw new Error("Asset inputs require canonical repository paths outside credential/runtime directories.");
|
|
122
|
+
}
|
|
123
|
+
return value;
|
|
124
|
+
};
|
|
125
|
+
/** Reject symlinks in every component, including the caller-provided root. */
|
|
126
|
+
const assertRegularPath = async (target, absolutePath, directory = false) => {
|
|
127
|
+
const resolved = plugins.path.resolve(absolutePath);
|
|
128
|
+
const parsed = plugins.path.parse(resolved);
|
|
129
|
+
let current = parsed.root;
|
|
130
|
+
const parts = resolved
|
|
131
|
+
.slice(parsed.root.length)
|
|
132
|
+
.split(plugins.path.sep)
|
|
133
|
+
.filter(Boolean);
|
|
134
|
+
for (let index = 0; index < parts.length; index++) {
|
|
135
|
+
current = plugins.path.join(current, parts[index]);
|
|
136
|
+
const stat = await plugins.fs.lstat(current);
|
|
137
|
+
const expectDirectory = index < parts.length - 1 || directory;
|
|
138
|
+
if (stat.isSymbolicLink() ||
|
|
139
|
+
(expectDirectory ? !stat.isDirectory() : !stat.isFile())) {
|
|
140
|
+
throw new Error(`${labelOf(target)} asset paths must use regular files and directories without symlinks.`);
|
|
141
|
+
}
|
|
142
|
+
}
|
|
143
|
+
};
|
|
144
|
+
/** Opens a regular file reached without any symlink, read-only. */
|
|
145
|
+
export const openReleaseAssetFile = async (target, path) => {
|
|
146
|
+
await assertRegularPath(target, path);
|
|
147
|
+
const handle = await plugins.fs.open(path, plugins.fsConstants.O_RDONLY | plugins.fsConstants.O_NOFOLLOW);
|
|
148
|
+
try {
|
|
149
|
+
if (!(await handle.stat()).isFile())
|
|
150
|
+
throw new Error(`${labelOf(target)} asset input is not a regular file.`);
|
|
151
|
+
return handle;
|
|
152
|
+
}
|
|
153
|
+
catch (error) {
|
|
154
|
+
await handle.close();
|
|
155
|
+
throw error;
|
|
156
|
+
}
|
|
157
|
+
};
|
|
158
|
+
const readBoundedFile = async (target, path, maximum) => {
|
|
159
|
+
const handle = await openReleaseAssetFile(target, path);
|
|
160
|
+
try {
|
|
161
|
+
if ((await handle.stat()).size > maximum)
|
|
162
|
+
throw new Error(`${labelOf(target)} asset metadata exceeds its size limit.`);
|
|
163
|
+
const chunks = [];
|
|
164
|
+
let size = 0;
|
|
165
|
+
for await (const chunk of handle.createReadStream({
|
|
166
|
+
autoClose: false,
|
|
167
|
+
highWaterMark: 64 * 1024,
|
|
168
|
+
})) {
|
|
169
|
+
size += chunk.length;
|
|
170
|
+
if (size > maximum)
|
|
171
|
+
throw new Error(`${labelOf(target)} asset metadata exceeds its size limit.`);
|
|
172
|
+
chunks.push(chunk);
|
|
173
|
+
}
|
|
174
|
+
return Buffer.concat(chunks, size);
|
|
175
|
+
}
|
|
176
|
+
finally {
|
|
177
|
+
await handle.close();
|
|
178
|
+
}
|
|
179
|
+
};
|
|
180
|
+
/** Hashes the whole open file; its size, hash and timestamps must match the frozen asset. */
|
|
181
|
+
export const verifyReleaseAssetFile = async (target, handle, asset) => {
|
|
182
|
+
const label = labelOf(target);
|
|
183
|
+
const before = await handle.stat();
|
|
184
|
+
if (before.size !== asset.size)
|
|
185
|
+
throw new Error(`Stored ${label} asset size conflicts with its frozen identity.`);
|
|
186
|
+
const hash = plugins.crypto.createHash("sha256");
|
|
187
|
+
let size = 0;
|
|
188
|
+
for await (const chunk of handle.createReadStream({
|
|
189
|
+
autoClose: false,
|
|
190
|
+
start: 0,
|
|
191
|
+
highWaterMark: 64 * 1024,
|
|
192
|
+
})) {
|
|
193
|
+
size += chunk.length;
|
|
194
|
+
if (size > asset.size)
|
|
195
|
+
throw new Error(`Stored ${label} asset exceeds its frozen size.`);
|
|
196
|
+
hash.update(chunk);
|
|
197
|
+
}
|
|
198
|
+
const after = await handle.stat();
|
|
199
|
+
if (size !== asset.size ||
|
|
200
|
+
hash.digest("hex") !== asset.sha256 ||
|
|
201
|
+
before.mtimeMs !== after.mtimeMs ||
|
|
202
|
+
before.ctimeMs !== after.ctimeMs) {
|
|
203
|
+
throw new Error(`Stored ${label} asset bytes conflict with their frozen identity.`);
|
|
204
|
+
}
|
|
205
|
+
};
|
|
206
|
+
export function assertReleaseFrozenAssets(target, assets, destination, tag) {
|
|
207
|
+
const label = labelOf(target);
|
|
208
|
+
if (!Array.isArray(assets) ||
|
|
209
|
+
assets.length === 0 ||
|
|
210
|
+
assets.length > releaseAssetTargets[target].maximumAssets)
|
|
211
|
+
throw new Error(`Invalid ${label} asset set.`);
|
|
212
|
+
const names = new Set();
|
|
213
|
+
for (const entry of assets) {
|
|
214
|
+
const asset = assertReleaseAssetRecord(target, entry);
|
|
215
|
+
exactKeys(target, asset, [
|
|
216
|
+
"name",
|
|
217
|
+
"size",
|
|
218
|
+
"sha256",
|
|
219
|
+
"fileName",
|
|
220
|
+
"publicUrl",
|
|
221
|
+
]);
|
|
222
|
+
const name = assertName(target, asset.name);
|
|
223
|
+
assertSizeAndHash(target, asset);
|
|
224
|
+
if (names.has(name) || asset.fileName !== releaseAssetFileName(target, name))
|
|
225
|
+
throw new Error(`Duplicate or invalid stored ${label} asset identity.`);
|
|
226
|
+
names.add(name);
|
|
227
|
+
let url;
|
|
228
|
+
try {
|
|
229
|
+
url = new URL(asset.publicUrl);
|
|
230
|
+
}
|
|
231
|
+
catch {
|
|
232
|
+
throw new Error(`Invalid frozen ${label} asset URL.`);
|
|
233
|
+
}
|
|
234
|
+
if (url.protocol !== "https:" ||
|
|
235
|
+
url.username ||
|
|
236
|
+
url.password ||
|
|
237
|
+
url.search ||
|
|
238
|
+
url.hash ||
|
|
239
|
+
url.href !== asset.publicUrl ||
|
|
240
|
+
(destination &&
|
|
241
|
+
tag &&
|
|
242
|
+
asset.publicUrl !==
|
|
243
|
+
releaseAssetPublicUrl(target, destination, tag, name))) {
|
|
244
|
+
throw new Error(`Frozen ${label} asset URL conflicts with its destination.`);
|
|
245
|
+
}
|
|
246
|
+
}
|
|
247
|
+
}
|
|
248
|
+
export const validateReleaseAssets = async (target, artifactDirectory, assets) => {
|
|
249
|
+
assertReleaseFrozenAssets(target, assets);
|
|
250
|
+
await assertRegularPath(target, artifactDirectory, true);
|
|
251
|
+
for (const asset of assets) {
|
|
252
|
+
const handle = await openReleaseAssetFile(target, plugins.path.join(artifactDirectory, asset.fileName));
|
|
253
|
+
try {
|
|
254
|
+
await verifyReleaseAssetFile(target, handle, asset);
|
|
255
|
+
}
|
|
256
|
+
finally {
|
|
257
|
+
await handle.close();
|
|
258
|
+
}
|
|
259
|
+
}
|
|
260
|
+
};
|
|
261
|
+
/**
|
|
262
|
+
* Reads the manifest `{schemaVersion: 1, version, assets: [{name, path, size,
|
|
263
|
+
* sha256}]}` and freezes each listed file into the release record directory,
|
|
264
|
+
* proving its bytes before and after the copy.
|
|
265
|
+
*/
|
|
266
|
+
export const prepareReleaseAssets = async (target, options) => {
|
|
267
|
+
const label = labelOf(target);
|
|
268
|
+
const destination = normalizeReleaseAssetDestination(target, options.destination);
|
|
269
|
+
assertReleaseAssetTag(target, options.tag);
|
|
270
|
+
if (!/^\d+\.\d+\.\d+(?:-[A-Za-z0-9.-]+)?(?:\+[A-Za-z0-9.-]+)?$/.test(options.version))
|
|
271
|
+
throw new Error(`Invalid ${label} asset manifest release version.`);
|
|
272
|
+
await assertRegularPath(target, options.repositoryRoot, true);
|
|
273
|
+
const manifestPath = plugins.path.join(options.repositoryRoot, assertRelativeAssetPath(options.manifestPath));
|
|
274
|
+
let manifest;
|
|
275
|
+
try {
|
|
276
|
+
manifest = assertReleaseAssetRecord(target, JSON.parse((await readBoundedFile(target, manifestPath, maximumManifestBytes)).toString("utf8")));
|
|
277
|
+
}
|
|
278
|
+
catch {
|
|
279
|
+
throw new Error(`Unable to read a bounded regular ${label} asset manifest.`);
|
|
280
|
+
}
|
|
281
|
+
exactKeys(target, manifest, ["schemaVersion", "version", "assets"]);
|
|
282
|
+
if (manifest.schemaVersion !== 1 ||
|
|
283
|
+
manifest.version !== options.version ||
|
|
284
|
+
!Array.isArray(manifest.assets) ||
|
|
285
|
+
manifest.assets.length === 0 ||
|
|
286
|
+
manifest.assets.length > releaseAssetTargets[target].maximumAssets)
|
|
287
|
+
throw new Error(`${label} asset manifest must match the exact release version and schema.`);
|
|
288
|
+
const paths = new Set();
|
|
289
|
+
const assets = manifest.assets.map((entry) => {
|
|
290
|
+
const input = assertReleaseAssetRecord(target, entry);
|
|
291
|
+
exactKeys(target, input, ["name", "path", "size", "sha256"]);
|
|
292
|
+
const path = assertRelativeAssetPath(input.path);
|
|
293
|
+
if (paths.has(path))
|
|
294
|
+
throw new Error(`${label} asset input paths must be unique.`);
|
|
295
|
+
paths.add(path);
|
|
296
|
+
const name = assertName(target, input.name);
|
|
297
|
+
assertSizeAndHash(target, input);
|
|
298
|
+
return {
|
|
299
|
+
name,
|
|
300
|
+
size: input.size,
|
|
301
|
+
sha256: input.sha256,
|
|
302
|
+
fileName: releaseAssetFileName(target, name),
|
|
303
|
+
publicUrl: releaseAssetPublicUrl(target, destination, options.tag, name),
|
|
304
|
+
};
|
|
305
|
+
});
|
|
306
|
+
assertReleaseFrozenAssets(target, assets, destination, options.tag);
|
|
307
|
+
// The journal owner creates this directory; never follow/create an unexpected root here.
|
|
308
|
+
await assertRegularPath(target, options.artifactDirectory, true);
|
|
309
|
+
for (let index = 0; index < assets.length; index++) {
|
|
310
|
+
const asset = assets[index];
|
|
311
|
+
const inputPath = plugins.path.join(options.repositoryRoot, [...paths][index]);
|
|
312
|
+
const input = await openReleaseAssetFile(target, inputPath);
|
|
313
|
+
try {
|
|
314
|
+
await verifyReleaseAssetFile(target, input, asset);
|
|
315
|
+
const outputPath = plugins.path.join(options.artifactDirectory, asset.fileName);
|
|
316
|
+
const output = await plugins.fs.open(outputPath, "wx", 0o600);
|
|
317
|
+
try {
|
|
318
|
+
let position = 0;
|
|
319
|
+
for await (const chunk of input.createReadStream({
|
|
320
|
+
autoClose: false,
|
|
321
|
+
start: 0,
|
|
322
|
+
highWaterMark: 64 * 1024,
|
|
323
|
+
})) {
|
|
324
|
+
if (position + chunk.length > asset.size)
|
|
325
|
+
throw new Error(`${label} asset changed during freezing.`);
|
|
326
|
+
let written = 0;
|
|
327
|
+
while (written < chunk.length) {
|
|
328
|
+
const result = await output.write(chunk, written, chunk.length - written, position + written);
|
|
329
|
+
if (!result.bytesWritten)
|
|
330
|
+
throw new Error(`Unable to freeze complete ${label} asset bytes.`);
|
|
331
|
+
written += result.bytesWritten;
|
|
332
|
+
}
|
|
333
|
+
position += chunk.length;
|
|
334
|
+
}
|
|
335
|
+
await output.sync();
|
|
336
|
+
}
|
|
337
|
+
finally {
|
|
338
|
+
await output.close();
|
|
339
|
+
}
|
|
340
|
+
// Includes detecting same-size mutation between the validation and copy passes.
|
|
341
|
+
await validateReleaseAssets(target, options.artifactDirectory, [asset]);
|
|
342
|
+
}
|
|
343
|
+
finally {
|
|
344
|
+
await input.close();
|
|
345
|
+
}
|
|
346
|
+
}
|
|
347
|
+
return assets;
|
|
348
|
+
};
|
|
349
|
+
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"helpers.releaseassets.js","sourceRoot":"","sources":["../../../ts/mod_release/helpers.releaseassets.ts"],"names":[],"mappings":"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"}
|
|
@@ -0,0 +1,67 @@
|
|
|
1
|
+
import { type TReleaseAssetFileHandle } from "./helpers.releaseassets.js";
|
|
2
|
+
import type { IReleaseAssetTransferFailures, IReleaseAssetTransferLimits, TReleaseAssetRequestFailureReason, TReleaseAssetTargetName, TReleaseAssetTransferDirection } from "./interfaces.releaseassets.js";
|
|
3
|
+
/** A duration as transfer messages print it: seconds with one decimal. */
|
|
4
|
+
export declare const formatReleaseAssetSeconds: (milliseconds: number) => string;
|
|
5
|
+
/**
|
|
6
|
+
* A request failure gitzone detected itself. Its message is the target's
|
|
7
|
+
* label in the fixed phrase of its reason and nothing else, so it carries no
|
|
8
|
+
* URL, header, body or token, and a request failure description prints it in
|
|
9
|
+
* full. The name stays `Error`; the message says what failed.
|
|
10
|
+
*/
|
|
11
|
+
export declare class ReleaseAssetRequestError extends Error {
|
|
12
|
+
readonly reason: TReleaseAssetRequestFailureReason;
|
|
13
|
+
constructor(target: TReleaseAssetTargetName, reason: TReleaseAssetRequestFailureReason);
|
|
14
|
+
}
|
|
15
|
+
/**
|
|
16
|
+
* Names why a request ended: the HTTP status it reached, each error of the
|
|
17
|
+
* cause chain by name and code, and how far the transfer got. A message is
|
|
18
|
+
* printed in full when gitzone raised it (a ReleaseAssetRequestError);
|
|
19
|
+
* any other error's message only when it is plain words ("terminated",
|
|
20
|
+
* "fetch failed", "other side closed"), since its text may carry a URL.
|
|
21
|
+
*/
|
|
22
|
+
export declare const describeReleaseAssetRequestFailure: (error: unknown, evidence: {
|
|
23
|
+
status?: number;
|
|
24
|
+
progress: string;
|
|
25
|
+
}) => string;
|
|
26
|
+
export declare const defaultReleaseAssetTransferLimits: Readonly<IReleaseAssetTransferLimits>;
|
|
27
|
+
export declare const assertReleaseAssetTransferLimits: (target: TReleaseAssetTargetName, limits: IReleaseAssetTransferLimits) => IReleaseAssetTransferLimits;
|
|
28
|
+
/**
|
|
29
|
+
* Bounds one request by progress instead of wall-clock time: the response
|
|
30
|
+
* bound covers waiting for headers, the stall bound restarts on every byte,
|
|
31
|
+
* an upload's acknowledgement wait scales with its size, and a ceiling of
|
|
32
|
+
* expected bytes at the rate floor ends a trickle. The target's failures
|
|
33
|
+
* name the bound that ended it.
|
|
34
|
+
*/
|
|
35
|
+
export declare class ReleaseAssetTransferWatchdog<TFailure extends Error> {
|
|
36
|
+
#private;
|
|
37
|
+
private readonly failures;
|
|
38
|
+
private readonly operation;
|
|
39
|
+
private readonly limits;
|
|
40
|
+
/** Bytes the request moves in total, including an upload body. */
|
|
41
|
+
private readonly expectedBytes;
|
|
42
|
+
private readonly uploadBytes;
|
|
43
|
+
constructor(failures: IReleaseAssetTransferFailures<TFailure>, operation: string, limits: IReleaseAssetTransferLimits,
|
|
44
|
+
/** Bytes the request moves in total, including an upload body. */
|
|
45
|
+
expectedBytes: number, uploadBytes?: number);
|
|
46
|
+
get signal(): AbortSignal;
|
|
47
|
+
get failure(): TFailure | undefined;
|
|
48
|
+
/** Bytes sent and received so far. */
|
|
49
|
+
get bytes(): number;
|
|
50
|
+
/** Wait for response headers; every redirect hop starts a new wait. */
|
|
51
|
+
awaitResponse(): void;
|
|
52
|
+
/** The whole upload body is sent; wait for the server to store and answer it. */
|
|
53
|
+
awaitAcknowledgement(): void;
|
|
54
|
+
/** Record moved bytes; the stall bound restarts from this moment. */
|
|
55
|
+
progress(direction: TReleaseAssetTransferDirection, bytes: number): void;
|
|
56
|
+
close(): void;
|
|
57
|
+
}
|
|
58
|
+
/**
|
|
59
|
+
* Streams exactly `size` bytes of the open file as a request body, pulled: the
|
|
60
|
+
* next chunk is read only when fetch has taken the last one, so progress means
|
|
61
|
+
* bytes the transport accepted. Sent with a `Content-Length` header, fetch
|
|
62
|
+
* (undici) writes that fixed length, never chunked transfer encoding, and
|
|
63
|
+
* fails the request when the body yields more or fewer bytes.
|
|
64
|
+
*/
|
|
65
|
+
export declare const createReleaseAssetUploadBody: <TFailure extends Error>(target: TReleaseAssetTargetName, handle: TReleaseAssetFileHandle, size: number, watchdog: ReleaseAssetTransferWatchdog<TFailure>) => ReadableStream<Uint8Array>;
|
|
66
|
+
/** Reads a whole response body of at most `maximum` bytes; every chunk is progress. */
|
|
67
|
+
export declare const readReleaseAssetResponse: <TFailure extends Error>(target: TReleaseAssetTargetName, response: Response, maximum: number, watchdog: ReleaseAssetTransferWatchdog<TFailure>) => Promise<Buffer>;
|