@adea-ai/app-framework 0.26.0 → 0.28.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/README.md +183 -17
- package/dist/app/create-application.d.ts +2 -0
- package/dist/app/create-application.js +6 -0
- package/dist/app/service-registry.js +4 -0
- package/dist/appearance/custom-theme-import.js +43 -7
- package/dist/appearance/custom-theme-library.d.ts +2 -0
- package/dist/appearance/custom-theme-library.js +5 -1
- package/dist/appearance/theme-record-adapter.js +4 -2
- package/dist/appearance/theme-registry.js +7 -1
- package/dist/cli/cef-helper-cli.js +0 -0
- package/dist/cli/create-application-cli.js +4 -2
- package/dist/cli/electrobun-shortcut-patch-cli.js +0 -0
- package/dist/cli/framework-update-cli.js +0 -0
- package/dist/cli/macos-signing-cli.js +0 -0
- package/dist/cli/release-assets-plan-cli.js +0 -0
- package/dist/cli/release-cut-cli.js +0 -0
- package/dist/cli/release-descriptor-staging-cli.js +0 -0
- package/dist/cli/release-finalize-cli.js +0 -0
- package/dist/cli/release-promote-cli.js +0 -0
- package/dist/cli/release-publish-cli.js +0 -0
- package/dist/cli/release-sign-cli.js +0 -0
- package/dist/cli/release-step-cli.js +6 -1
- package/dist/cli/toolchain-identity-cli.js +0 -0
- package/dist/cli/update-helper-cli.js +28 -6
- package/dist/cli/windows-runtime-patch-cli.js +0 -0
- package/dist/desktop/client-asset-manifest.d.ts +47 -0
- package/dist/desktop/client-asset-manifest.js +114 -0
- package/dist/desktop/client-asset-stream.d.ts +10 -0
- package/dist/desktop/client-asset-stream.js +138 -33
- package/dist/desktop/client-assets.d.ts +20 -0
- package/dist/desktop/client-assets.js +132 -22
- package/dist/desktop/client-response-lifecycle.d.ts +22 -0
- package/dist/desktop/client-response-lifecycle.js +233 -0
- package/dist/desktop/desktop-host.d.ts +40 -2
- package/dist/desktop/desktop-host.js +159 -9
- package/dist/framework-source.json +1 -1
- package/dist/installer/command-artifact.d.ts +4 -2
- package/dist/installer/command-artifact.js +119 -19
- package/dist/installer/installer-identity.d.ts +4 -1
- package/dist/installer/installer-identity.js +6 -3
- package/dist/installer/installer-layout.d.ts +2 -0
- package/dist/installer/installer-layout.js +5 -1
- package/dist/installer/linux-process-group.d.ts +13 -0
- package/dist/installer/linux-process-group.js +58 -0
- package/dist/native/darwin-sync.d.ts +7 -0
- package/dist/native/darwin-sync.js +43 -0
- package/dist/native/desktop-build-hook.js +7 -0
- package/dist/native/directory-exchange.d.ts +10 -0
- package/dist/native/directory-exchange.js +90 -0
- package/dist/native/electrobun-source-patch.d.ts +5 -0
- package/dist/native/electrobun-source-patch.js +19 -1
- package/dist/native/posix-launcher-build.d.ts +24 -0
- package/dist/native/posix-launcher-build.js +232 -0
- package/dist/native/posix-tree-removal.d.ts +36 -0
- package/dist/native/posix-tree-removal.js +425 -0
- package/dist/release/release-steps.d.ts +5 -0
- package/dist/release/release-steps.js +2 -1
- package/dist/update-helper.bundle.js +1483 -105
- package/dist/updates/channel-update-manager.d.ts +5 -0
- package/dist/updates/channel-update-manager.js +13 -1
- package/dist/updates/desktop-updater.d.ts +78 -2
- package/dist/updates/desktop-updater.js +320 -37
- package/dist/updates/launch-environment.d.ts +2 -0
- package/dist/updates/launch-environment.js +4 -0
- package/dist/updates/native-file-lock.d.ts +15 -0
- package/dist/updates/native-file-lock.js +189 -0
- package/dist/updates/packaged-launch-admission.d.ts +13 -0
- package/dist/updates/packaged-launch-admission.js +45 -0
- package/dist/updates/packaged-release-config.d.ts +18 -0
- package/dist/updates/packaged-release-config.js +60 -0
- package/dist/updates/packaged-update-startup.d.ts +44 -0
- package/dist/updates/packaged-update-startup.js +81 -0
- package/dist/updates/update-arm.d.ts +9 -8
- package/dist/updates/update-arm.js +227 -62
- package/dist/updates/update-cleanup-error.d.ts +23 -0
- package/dist/updates/update-cleanup-error.js +65 -0
- package/dist/updates/update-download-cleanup.d.ts +11 -0
- package/dist/updates/update-download-cleanup.js +112 -2
- package/dist/updates/update-download-lock.d.ts +20 -0
- package/dist/updates/update-download-lock.js +73 -0
- package/dist/updates/update-download.d.ts +2 -0
- package/dist/updates/update-download.js +7 -3
- package/dist/updates/update-generation-lease.d.ts +6 -0
- package/dist/updates/update-generation-lease.js +14 -0
- package/dist/updates/update-helper.d.ts +11 -2
- package/dist/updates/update-helper.js +322 -13
- package/dist/updates/update-inherited-launch-lease.d.ts +22 -0
- package/dist/updates/update-inherited-launch-lease.js +58 -0
- package/dist/updates/update-instance-lease.d.ts +15 -0
- package/dist/updates/update-instance-lease.js +25 -0
- package/dist/updates/update-launch-gate.d.ts +137 -0
- package/dist/updates/update-launch-gate.js +617 -0
- package/dist/updates/update-launch.js +3 -1
- package/dist/updates/update-lock.d.ts +12 -0
- package/dist/updates/update-lock.js +18 -0
- package/dist/updates/update-manager.d.ts +2 -0
- package/dist/updates/update-manager.js +9 -2
- package/dist/updates/update-marker.d.ts +7 -0
- package/dist/updates/update-marker.js +62 -0
- package/dist/updates/update-preflight-error.d.ts +7 -0
- package/dist/updates/update-preflight-error.js +11 -0
- package/dist/updates/update-process-fence.d.ts +4 -0
- package/dist/updates/update-process-fence.js +85 -73
- package/dist/updates/update-process-liveness.d.ts +2 -0
- package/dist/updates/update-process-liveness.js +11 -0
- package/dist/updates/update-resume.d.ts +37 -3
- package/dist/updates/update-resume.js +839 -23
- package/dist/updates/update-retention-marker.d.ts +67 -0
- package/dist/updates/update-retention-marker.js +165 -0
- package/dist/updates/update-retention-plan.d.ts +25 -0
- package/dist/updates/update-retention-plan.js +54 -0
- package/dist/updates/update-retention-sync.d.ts +34 -0
- package/dist/updates/update-retention-sync.js +83 -0
- package/dist/updates/update-retirement.d.ts +205 -0
- package/dist/updates/update-retirement.js +1485 -0
- package/dist/updates/update-shutdown.d.ts +16 -4
- package/dist/updates/update-shutdown.js +133 -8
- package/dist/updates/update-state-store.d.ts +58 -0
- package/dist/updates/update-state-store.js +139 -0
- package/dist/updates/update-swap-stage.d.ts +1 -1
- package/dist/updates/update-swap-stage.js +85 -14
- package/dist/updates/update-swap.d.ts +45 -2
- package/dist/updates/update-swap.js +207 -17
- package/package.json +31 -1
- package/src/appearance/custom-theme-import.ts +96 -14
- package/src/appearance/custom-theme-library.ts +5 -0
- package/src/appearance/theme-record-adapter.ts +15 -6
- package/src/appearance/theme-registry.ts +8 -1
- package/src/desktop/client-asset-manifest.ts +207 -0
- package/src/desktop/client-asset-stream.ts +193 -32
- package/src/desktop/client-assets.ts +210 -19
- package/src/desktop/client-response-lifecycle.ts +305 -0
- package/src/native/electrobun-posix-launch-lease.patch +398 -0
- package/templates/application/README.md +50 -0
- package/templates/application/electrobun.config.ts +5 -1
- package/templates/application/scripts/build-desktop.ts +4 -0
- package/templates/application/src/bun/index.ts +173 -16
- package/templates/application/vite.config.ts +112 -6
|
@@ -1,34 +1,850 @@
|
|
|
1
|
-
import {
|
|
2
|
-
import {
|
|
1
|
+
import { verifyReleaseDescriptor } from "./signed-release.js";
|
|
2
|
+
import { renameUpdateExclusive } from "./update-exclusive-rename.js";
|
|
3
|
+
import { tryAcquireUpdateLock } from "./update-lock.js";
|
|
4
|
+
import { UpdateLockBusyError, acquireUpdateLock, readUpdateStageState, syncUpdateStageDirectory, writeUpdateStageState, writeUpdateStageStateDurably } from "./update-state-store.js";
|
|
5
|
+
import { readUpdateTreeDigest, readUpdateTreeIdentity, readUpdateTreeVersion, sameUpdateTreeDigest, sameUpdateTreeIdentity, syncUpdateTreeParent, updateStagingFor } from "./update-swap.js";
|
|
6
|
+
import { readUpdateMarker } from "./update-marker.js";
|
|
7
|
+
import { tryAcquireUpdateInstanceLease } from "./update-instance-lease.js";
|
|
8
|
+
import { readUpdateLaunchGate, tryAcquireUpdateHelperLiveness, tryRecoverUpdateLaunchGate } from "./update-launch-gate.js";
|
|
9
|
+
import { hasUpdateHelperArtifacts, parseUpdateHelperRequest } from "./update-helper.js";
|
|
10
|
+
import { updateProcessMayBeAlive } from "./update-process-liveness.js";
|
|
11
|
+
import { acquireRetainedUpdateTrees, acquireRetainedUpdateTreesWhileLocked, reconcileRetirementCleanupMarkerWhileLocked, retireCompletedUpdateWhileLocked } from "./update-retirement.js";
|
|
12
|
+
import { lstat, open, readFile, readdir, realpath, rm, rmdir, unlink } from "node:fs/promises";
|
|
3
13
|
import { join } from "node:path";
|
|
14
|
+
import { constants as constants$1 } from "node:fs";
|
|
15
|
+
import { randomUUID } from "node:crypto";
|
|
4
16
|
// src/updates/update-resume.ts
|
|
5
|
-
function
|
|
17
|
+
async function exists(path) {
|
|
18
|
+
return lstat(path).then(() => true, (error) => {
|
|
19
|
+
if (error.code === "ENOENT") return false;
|
|
20
|
+
throw error;
|
|
21
|
+
});
|
|
22
|
+
}
|
|
23
|
+
/** Validate the empty extraction remainder left by the legacy stage publisher. */
|
|
24
|
+
async function isLegacyExtractionRemainder(path) {
|
|
25
|
+
const info = await lstat(path);
|
|
26
|
+
if (!info.isDirectory() || info.isSymbolicLink()) return false;
|
|
27
|
+
const entries = await readdir(path);
|
|
28
|
+
if (entries.length !== 1 || entries[0] !== "payload") return false;
|
|
29
|
+
const payload = join(path, "payload");
|
|
30
|
+
const payloadInfo = await lstat(payload);
|
|
31
|
+
return payloadInfo.isDirectory() && !payloadInfo.isSymbolicLink() && (await readdir(payload)).length === 0;
|
|
32
|
+
}
|
|
33
|
+
async function readTreeDigestForProof(path) {
|
|
6
34
|
try {
|
|
7
|
-
|
|
8
|
-
|
|
35
|
+
return await readUpdateTreeDigest(path);
|
|
36
|
+
} catch {
|
|
37
|
+
return;
|
|
38
|
+
}
|
|
39
|
+
}
|
|
40
|
+
/** Recover only layouts produced by a proven-exited legacy helper. */
|
|
41
|
+
async function recoverLegacyHandoff(options) {
|
|
42
|
+
const { target, staging, currentVersion, helperPid } = options;
|
|
43
|
+
if (!Number.isSafeInteger(helperPid) || helperPid < 2 || updateProcessMayBeAlive(helperPid)) return { status: "recovery-required" };
|
|
44
|
+
let request;
|
|
45
|
+
try {
|
|
46
|
+
const path = join(staging, "request.json");
|
|
47
|
+
const info = await lstat(path);
|
|
48
|
+
if (!info.isFile() || info.isSymbolicLink() || info.size < 1 || info.size > 65536) return { status: "recovery-required" };
|
|
49
|
+
request = parseUpdateHelperRequest(JSON.parse(await readFile(path, "utf8")));
|
|
50
|
+
} catch {
|
|
51
|
+
return { status: "recovery-required" };
|
|
52
|
+
}
|
|
53
|
+
const nativePlatform = process.platform === "darwin" && process.arch === "arm64" ? "macos-arm64" : process.platform === "win32" && process.arch === "x64" ? "windows-x64" : process.platform === "linux" && process.arch === "x64" ? "linux-x64" : void 0;
|
|
54
|
+
if (request.schema !== 1 || request.target !== target || request.platform !== nativePlatform || request.version === currentVersion) return { status: "recovery-required" };
|
|
55
|
+
const allowed = /* @__PURE__ */ new Set([
|
|
56
|
+
"candidate",
|
|
57
|
+
"helper",
|
|
58
|
+
"helper-armed",
|
|
59
|
+
"old",
|
|
60
|
+
"request.json"
|
|
61
|
+
]);
|
|
62
|
+
for (const name of await readdir(staging)) {
|
|
63
|
+
if (allowed.has(name)) continue;
|
|
64
|
+
if (!/^framework-update-extract-[a-z0-9]{6}$/i.test(name)) return { status: "recovery-required" };
|
|
65
|
+
try {
|
|
66
|
+
if (!await isLegacyExtractionRemainder(join(staging, name))) return { status: "recovery-required" };
|
|
67
|
+
} catch {
|
|
68
|
+
return { status: "recovery-required" };
|
|
69
|
+
}
|
|
70
|
+
}
|
|
71
|
+
const candidate = join(staging, "candidate");
|
|
72
|
+
const old = join(staging, "old");
|
|
73
|
+
const [targetExists, candidateExists, oldExists] = await Promise.all([
|
|
74
|
+
exists(target),
|
|
75
|
+
exists(candidate),
|
|
76
|
+
exists(old)
|
|
77
|
+
]);
|
|
78
|
+
if (!candidateExists || await readUpdateTreeVersion(candidate) !== request.version) return { status: "recovery-required" };
|
|
79
|
+
const candidateInfo = await lstat(candidate);
|
|
80
|
+
if (!candidateInfo.isDirectory() || candidateInfo.isSymbolicLink()) return { status: "recovery-required" };
|
|
81
|
+
if (!targetExists && oldExists) {
|
|
82
|
+
const oldInfo = await lstat(old);
|
|
83
|
+
if (!oldInfo.isDirectory() || oldInfo.isSymbolicLink() || await readUpdateTreeVersion(old) !== currentVersion) return { status: "recovery-required" };
|
|
84
|
+
renameUpdateExclusive(old, target);
|
|
85
|
+
} else if (targetExists && !oldExists) {
|
|
86
|
+
const targetInfo = await lstat(target);
|
|
87
|
+
if (!targetInfo.isDirectory() || targetInfo.isSymbolicLink() || await readUpdateTreeVersion(target) !== currentVersion) return { status: "recovery-required" };
|
|
88
|
+
} else return { status: "recovery-required" };
|
|
89
|
+
const archived = `${staging}.legacy-${randomUUID()}`;
|
|
90
|
+
renameUpdateExclusive(staging, archived);
|
|
91
|
+
return { status: "not-applied" };
|
|
92
|
+
}
|
|
93
|
+
async function resetToStaged(staging, state) {
|
|
94
|
+
const { helperPid: _helperPid, helperOwner: _helperOwner, previousTreeIdentity: _previousTreeIdentity, ...recoverable } = state;
|
|
95
|
+
const next = {
|
|
96
|
+
...recoverable,
|
|
97
|
+
phase: "staged"
|
|
98
|
+
};
|
|
99
|
+
await clearHelperArtifacts(staging);
|
|
100
|
+
await writeUpdateStageState(staging, next);
|
|
101
|
+
return next;
|
|
102
|
+
}
|
|
103
|
+
async function clearHelperArtifacts(staging) {
|
|
104
|
+
await rm(join(staging, "request.json"), { force: true });
|
|
105
|
+
await rm(join(staging, "helper-armed"), { force: true });
|
|
106
|
+
await rm(join(staging, "helper-ready"), { force: true });
|
|
107
|
+
await rm(join(staging, "cancel.json"), { force: true });
|
|
108
|
+
await rm(join(staging, "cancel-ack.json"), { force: true });
|
|
109
|
+
await rm(join(staging, "helper"), {
|
|
110
|
+
recursive: true,
|
|
111
|
+
force: true
|
|
112
|
+
});
|
|
113
|
+
}
|
|
114
|
+
var knownStagingEntries = /* @__PURE__ */ new Set([
|
|
115
|
+
"candidate",
|
|
116
|
+
"helper",
|
|
117
|
+
"helper-armed",
|
|
118
|
+
"helper-ready",
|
|
119
|
+
"cancel.json",
|
|
120
|
+
"cancel-ack.json",
|
|
121
|
+
"request.json",
|
|
122
|
+
"state.json"
|
|
123
|
+
]);
|
|
124
|
+
async function hasUnknownStagingEntries(staging, allowed = [], generation) {
|
|
125
|
+
const entries = await readdir(staging);
|
|
126
|
+
const stateTemporary = generation ? new RegExp(`^\\.state-${generation}-[0-9a-f-]{36}\\.tmp$`, "i") : void 0;
|
|
127
|
+
return entries.some((entry) => !knownStagingEntries.has(entry) && !allowed.includes(entry) && !(stateTemporary?.test(entry) ?? false));
|
|
128
|
+
}
|
|
129
|
+
async function reconcileSwap(target, staging, state) {
|
|
130
|
+
const candidate = join(staging, "candidate");
|
|
131
|
+
const old = join(staging, "old");
|
|
132
|
+
if (!await exists(target) && await exists(old) && await exists(candidate)) {
|
|
133
|
+
if (await hasUnknownStagingEntries(staging, ["old"], state.generation)) return void 0;
|
|
134
|
+
try {
|
|
135
|
+
const [oldInfo, candidateInfo] = await Promise.all([lstat(old), lstat(candidate)]);
|
|
136
|
+
const [oldIdentity, candidateIdentity] = await Promise.all([readUpdateTreeIdentity(old), readUpdateTreeIdentity(candidate)]);
|
|
137
|
+
if (!oldInfo.isDirectory() || oldInfo.isSymbolicLink() || !candidateInfo.isDirectory() || candidateInfo.isSymbolicLink() || !oldIdentity || !candidateIdentity || !sameUpdateTreeIdentity(candidateIdentity, state.candidateTreeIdentity) || sameUpdateTreeIdentity(oldIdentity, candidateIdentity) || state.previousTreeIdentity && !sameUpdateTreeIdentity(oldIdentity, state.previousTreeIdentity) || await readUpdateTreeVersion(old) !== state.previousVersion || await readUpdateTreeVersion(candidate) !== state.version || state.candidateTreeDigest !== void 0 && !sameUpdateTreeDigest(await readTreeDigestForProof(candidate), state.candidateTreeDigest)) return void 0;
|
|
138
|
+
renameUpdateExclusive(old, target);
|
|
139
|
+
return resetToStaged(staging, state);
|
|
140
|
+
} catch {
|
|
141
|
+
return;
|
|
142
|
+
}
|
|
143
|
+
}
|
|
144
|
+
if (await exists(old) || await hasUnknownStagingEntries(staging, [], state.generation) || !await exists(target) || !await exists(candidate)) return void 0;
|
|
145
|
+
try {
|
|
146
|
+
const [targetInfo, candidateInfo] = await Promise.all([lstat(target), lstat(candidate)]);
|
|
147
|
+
if (!targetInfo.isDirectory() || targetInfo.isSymbolicLink() || !candidateInfo.isDirectory() || candidateInfo.isSymbolicLink()) return void 0;
|
|
148
|
+
} catch {
|
|
149
|
+
return;
|
|
150
|
+
}
|
|
151
|
+
const [targetVersion, candidateVersion] = await Promise.all([readUpdateTreeVersion(target), readUpdateTreeVersion(candidate)]);
|
|
152
|
+
const [targetIdentity, candidateIdentity] = await Promise.all([readUpdateTreeIdentity(target), readUpdateTreeIdentity(candidate)]);
|
|
153
|
+
if (targetVersion === state.previousVersion && candidateVersion === state.version && targetIdentity !== void 0 && candidateIdentity !== void 0 && sameUpdateTreeIdentity(candidateIdentity, state.candidateTreeIdentity) && (state.candidateTreeDigest === void 0 || sameUpdateTreeDigest(await readTreeDigestForProof(candidate), state.candidateTreeDigest)) && !sameUpdateTreeIdentity(targetIdentity, candidateIdentity) && (!state.previousTreeIdentity || sameUpdateTreeIdentity(targetIdentity, state.previousTreeIdentity))) return resetToStaged(staging, state);
|
|
154
|
+
if (targetVersion === state.version && candidateVersion === state.previousVersion && sameUpdateTreeIdentity(targetIdentity, state.candidateTreeIdentity) && (state.candidateTreeDigest === void 0 || sameUpdateTreeDigest(await readTreeDigestForProof(target), state.candidateTreeDigest)) && sameUpdateTreeIdentity(candidateIdentity, state.previousTreeIdentity)) {
|
|
155
|
+
const completed = {
|
|
156
|
+
...state,
|
|
157
|
+
phase: "completed"
|
|
158
|
+
};
|
|
159
|
+
await writeUpdateStageState(staging, completed);
|
|
160
|
+
return completed;
|
|
161
|
+
}
|
|
162
|
+
}
|
|
163
|
+
async function recoverStagedCandidate(options) {
|
|
164
|
+
const { target, staging, state, trust, currentVersion } = options;
|
|
165
|
+
if (!state.candidateTreeDigest && !options.allowDigestlessLegacy) return { status: "recovery-required" };
|
|
166
|
+
if (!state.signedRelease || state.previousVersion !== currentVersion) return { status: "recovery-required" };
|
|
167
|
+
const verified = verifyReleaseDescriptor(state.signedRelease, trust);
|
|
168
|
+
if (!verified.ok || verified.descriptor.version !== state.version) return { status: "recovery-required" };
|
|
169
|
+
if (await readUpdateTreeVersion(target) !== currentVersion) return { status: "recovery-required" };
|
|
170
|
+
const candidate = join(staging, "candidate");
|
|
171
|
+
let info;
|
|
172
|
+
try {
|
|
173
|
+
info = await lstat(candidate);
|
|
9
174
|
} catch (error) {
|
|
10
|
-
|
|
175
|
+
if (error.code === "ENOENT") return { status: "recovery-required" };
|
|
176
|
+
throw error;
|
|
11
177
|
}
|
|
178
|
+
if (!info.isDirectory() || info.isSymbolicLink()) return { status: "recovery-required" };
|
|
179
|
+
if (await exists(join(staging, "old")) || await readUpdateTreeVersion(candidate) !== state.version || !sameUpdateTreeIdentity(await readUpdateTreeIdentity(candidate), state.candidateTreeIdentity) || state.candidateTreeDigest !== void 0 && !sameUpdateTreeDigest(await readTreeDigestForProof(candidate), state.candidateTreeDigest)) return { status: "recovery-required" };
|
|
180
|
+
return {
|
|
181
|
+
status: "staged",
|
|
182
|
+
version: state.version,
|
|
183
|
+
channel: verified.descriptor.channel
|
|
184
|
+
};
|
|
12
185
|
}
|
|
13
|
-
|
|
14
|
-
|
|
15
|
-
|
|
16
|
-
|
|
17
|
-
|
|
18
|
-
|
|
19
|
-
|
|
20
|
-
|
|
186
|
+
async function resumeLocked(options) {
|
|
187
|
+
const { target, staging, trust, currentVersion } = options;
|
|
188
|
+
const launchGate = await readUpdateLaunchGate(target);
|
|
189
|
+
if (!await exists(staging)) {
|
|
190
|
+
if (launchGate) return { status: "recovery-required" };
|
|
191
|
+
const cleanup = await reconcileRetirementCleanupMarkerWhileLocked({
|
|
192
|
+
target,
|
|
193
|
+
staging,
|
|
194
|
+
currentVersion
|
|
195
|
+
});
|
|
196
|
+
return cleanup === "none" ? { status: "none" } : cleanup === "updated" ? {
|
|
197
|
+
status: "updated",
|
|
198
|
+
version: currentVersion
|
|
199
|
+
} : { status: "recovery-required" };
|
|
200
|
+
}
|
|
201
|
+
const info = await lstat(staging);
|
|
21
202
|
if (!info.isDirectory() || info.isSymbolicLink()) throw new Error("Unexpected update staging entry");
|
|
22
|
-
|
|
23
|
-
if (
|
|
24
|
-
|
|
25
|
-
|
|
203
|
+
let state = await readUpdateStageState(staging);
|
|
204
|
+
if (!state) {
|
|
205
|
+
if (launchGate) return { status: "recovery-required" };
|
|
206
|
+
const cleanup = await reconcileRetirementCleanupMarkerWhileLocked({
|
|
207
|
+
target,
|
|
208
|
+
staging,
|
|
209
|
+
currentVersion
|
|
210
|
+
});
|
|
211
|
+
if (cleanup !== "none") return cleanup === "updated" ? {
|
|
212
|
+
status: "updated",
|
|
213
|
+
version: currentVersion
|
|
214
|
+
} : { status: "recovery-required" };
|
|
215
|
+
const helper = Number(await readFile(join(staging, "helper-armed"), "utf8").catch(() => 0));
|
|
216
|
+
if (Number.isSafeInteger(helper) && helper > 1 && updateProcessMayBeAlive(helper)) return { status: "in-progress" };
|
|
217
|
+
const legacyVersion = await readFile(join(staging, "updated"), "utf8").catch(() => void 0);
|
|
218
|
+
if (legacyVersion && await readUpdateTreeVersion(target) === legacyVersion) {
|
|
219
|
+
const entries = await readdir(staging);
|
|
220
|
+
if (entries.length !== 1 || entries[0] !== "updated") return { status: "recovery-required" };
|
|
221
|
+
await unlink(join(staging, "updated"));
|
|
222
|
+
await rmdir(staging);
|
|
223
|
+
return {
|
|
224
|
+
status: "updated",
|
|
225
|
+
version: legacyVersion
|
|
226
|
+
};
|
|
227
|
+
}
|
|
228
|
+
if (Number.isSafeInteger(helper) && helper > 1) return recoverLegacyHandoff({
|
|
229
|
+
target,
|
|
230
|
+
staging,
|
|
231
|
+
currentVersion,
|
|
232
|
+
helperPid: helper
|
|
233
|
+
});
|
|
234
|
+
if ((await readdir(staging)).length === 0) {
|
|
235
|
+
await rmdir(staging);
|
|
236
|
+
return { status: "not-applied" };
|
|
237
|
+
}
|
|
238
|
+
return { status: "recovery-required" };
|
|
239
|
+
}
|
|
240
|
+
if (launchGate) {
|
|
241
|
+
if (state.launchGateOwner !== launchGate.owner || state.generation !== launchGate.generation || state.version !== launchGate.version) return { status: "recovery-required" };
|
|
242
|
+
if (state.helperPid && updateProcessMayBeAlive(state.helperPid)) return { status: "in-progress" };
|
|
243
|
+
return { status: "recovery-required" };
|
|
244
|
+
}
|
|
245
|
+
if (state.launchGateOwner !== void 0 && state.phase !== "completed" && state.phase !== "retiring" && state.phase !== "retired") return { status: "recovery-required" };
|
|
246
|
+
if (state.helperPid && updateProcessMayBeAlive(state.helperPid)) return { status: "in-progress" };
|
|
247
|
+
if (!state.helperPid && await hasUpdateHelperArtifacts(staging)) return { status: "recovery-required" };
|
|
248
|
+
if (state.launchGateOwner && !state.candidateTreeDigest) return { status: "recovery-required" };
|
|
249
|
+
if (state.phase === "staged") {
|
|
250
|
+
if (state.helperPid) state = await resetToStaged(staging, state);
|
|
251
|
+
return recoverStagedCandidate({
|
|
252
|
+
target,
|
|
253
|
+
staging,
|
|
254
|
+
state,
|
|
255
|
+
trust,
|
|
256
|
+
currentVersion
|
|
257
|
+
});
|
|
258
|
+
}
|
|
259
|
+
if (state.phase === "armed") {
|
|
260
|
+
state = await resetToStaged(staging, state);
|
|
261
|
+
return recoverStagedCandidate({
|
|
262
|
+
target,
|
|
263
|
+
staging,
|
|
264
|
+
state,
|
|
265
|
+
trust,
|
|
266
|
+
currentVersion,
|
|
267
|
+
allowDigestlessLegacy: true
|
|
268
|
+
});
|
|
269
|
+
}
|
|
270
|
+
if (state.phase === "swapping") {
|
|
271
|
+
const reconciled = await reconcileSwap(target, staging, state);
|
|
272
|
+
if (!reconciled) return { status: "recovery-required" };
|
|
273
|
+
state = reconciled;
|
|
274
|
+
if (state.phase === "completed") {
|
|
275
|
+
if (await readUpdateTreeVersion(target) !== state.version) return { status: "recovery-required" };
|
|
276
|
+
if (!await retireCompletedUpdateWhileLocked({
|
|
277
|
+
target,
|
|
278
|
+
staging,
|
|
279
|
+
state
|
|
280
|
+
})) return { status: "recovery-required" };
|
|
281
|
+
return {
|
|
282
|
+
status: "updated",
|
|
283
|
+
version: state.version
|
|
284
|
+
};
|
|
285
|
+
}
|
|
286
|
+
if (state.helperPid) state = await resetToStaged(staging, state);
|
|
287
|
+
return recoverStagedCandidate({
|
|
288
|
+
target,
|
|
289
|
+
staging,
|
|
290
|
+
state,
|
|
291
|
+
trust,
|
|
292
|
+
currentVersion,
|
|
293
|
+
allowDigestlessLegacy: true
|
|
294
|
+
});
|
|
295
|
+
}
|
|
296
|
+
if (state.phase === "completed") {
|
|
297
|
+
if (await readUpdateTreeVersion(target) !== state.version || !sameUpdateTreeIdentity(await readUpdateTreeIdentity(target), state.candidateTreeIdentity) || state.candidateTreeDigest !== void 0 && !sameUpdateTreeDigest(await readTreeDigestForProof(target), state.candidateTreeDigest)) return { status: "recovery-required" };
|
|
298
|
+
if (!await retireCompletedUpdateWhileLocked({
|
|
299
|
+
target,
|
|
300
|
+
staging,
|
|
301
|
+
state
|
|
302
|
+
})) return { status: "recovery-required" };
|
|
303
|
+
return {
|
|
304
|
+
status: "updated",
|
|
305
|
+
version: state.version
|
|
306
|
+
};
|
|
307
|
+
}
|
|
308
|
+
if (state.phase === "retiring" || state.phase === "retired") {
|
|
309
|
+
if (await readUpdateTreeVersion(target) !== state.version || !sameUpdateTreeIdentity(await readUpdateTreeIdentity(target), state.candidateTreeIdentity) || state.candidateTreeDigest !== void 0 && !sameUpdateTreeDigest(await readTreeDigestForProof(target), state.candidateTreeDigest)) return { status: "recovery-required" };
|
|
310
|
+
if (!await retireCompletedUpdateWhileLocked({
|
|
311
|
+
target,
|
|
312
|
+
staging,
|
|
313
|
+
state
|
|
314
|
+
})) return { status: "recovery-required" };
|
|
315
|
+
return {
|
|
316
|
+
status: "updated",
|
|
317
|
+
version: state.version
|
|
318
|
+
};
|
|
319
|
+
}
|
|
320
|
+
if (state.phase === "failed") {
|
|
321
|
+
state = await resetToStaged(staging, state);
|
|
322
|
+
return recoverStagedCandidate({
|
|
323
|
+
target,
|
|
324
|
+
staging,
|
|
325
|
+
state,
|
|
326
|
+
trust,
|
|
327
|
+
currentVersion,
|
|
328
|
+
allowDigestlessLegacy: true
|
|
329
|
+
});
|
|
330
|
+
}
|
|
331
|
+
throw new Error("Invalid update staging phase");
|
|
332
|
+
}
|
|
333
|
+
var recoveryUuid = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
|
|
334
|
+
var recoveryStagingEntries = /* @__PURE__ */ new Set([
|
|
335
|
+
"candidate",
|
|
336
|
+
"helper",
|
|
337
|
+
"helper-armed",
|
|
338
|
+
"helper-ready",
|
|
339
|
+
"cancel.json",
|
|
340
|
+
"cancel-ack.json",
|
|
341
|
+
"request.json",
|
|
342
|
+
"state.json"
|
|
343
|
+
]);
|
|
344
|
+
function hasExactKeys(value, keys) {
|
|
345
|
+
const actual = Object.keys(value).toSorted();
|
|
346
|
+
const expected = keys.toSorted();
|
|
347
|
+
return actual.length === expected.length && actual.every((key, index) => key === expected[index]);
|
|
348
|
+
}
|
|
349
|
+
async function readOptionalRecoveryFile(path, maxBytes) {
|
|
350
|
+
let info;
|
|
351
|
+
try {
|
|
352
|
+
info = await lstat(path);
|
|
353
|
+
} catch (error) {
|
|
354
|
+
if (error.code === "ENOENT") return void 0;
|
|
355
|
+
throw error;
|
|
356
|
+
}
|
|
357
|
+
if (!info.isFile() || info.isSymbolicLink() || info.size < 1 || info.size > maxBytes) throw new Error("Invalid schema-3 helper recovery artifact");
|
|
358
|
+
const file = await open(path, constants$1.O_RDONLY | (constants$1.O_NOFOLLOW ?? 0));
|
|
359
|
+
try {
|
|
360
|
+
const opened = await file.stat();
|
|
361
|
+
if (!opened.isFile() || opened.size < 1 || opened.size > maxBytes) throw new Error("Invalid schema-3 helper recovery artifact");
|
|
362
|
+
return await file.readFile("utf8");
|
|
363
|
+
} finally {
|
|
364
|
+
await file.close();
|
|
365
|
+
}
|
|
366
|
+
}
|
|
367
|
+
async function recoveryInventoryIsKnown(staging, state) {
|
|
368
|
+
const names = await readdir(staging);
|
|
369
|
+
const stateTemporary = new RegExp(`^\\.state-${state.generation}-[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}\\.tmp$`, "i");
|
|
370
|
+
for (const name of names) {
|
|
371
|
+
if (recoveryStagingEntries.has(name)) continue;
|
|
372
|
+
if (!stateTemporary.test(name)) return false;
|
|
373
|
+
const path = join(staging, name);
|
|
374
|
+
const info = await lstat(path);
|
|
375
|
+
if (!info.isFile() || info.isSymbolicLink() || info.size > 4096) return false;
|
|
376
|
+
}
|
|
377
|
+
if (!names.includes("candidate") || !names.includes("state.json")) return false;
|
|
378
|
+
for (const name of names) {
|
|
379
|
+
const info = await lstat(join(staging, name));
|
|
380
|
+
if (stateTemporary.test(name)) {
|
|
381
|
+
if (!info.isFile() || info.isSymbolicLink()) return false;
|
|
382
|
+
continue;
|
|
383
|
+
}
|
|
384
|
+
if (name === "candidate" || name === "helper") {
|
|
385
|
+
if (!info.isDirectory() || info.isSymbolicLink()) return false;
|
|
386
|
+
} else if (!info.isFile() || info.isSymbolicLink()) return false;
|
|
387
|
+
}
|
|
388
|
+
return true;
|
|
389
|
+
}
|
|
390
|
+
async function isCanonicalRecoveryStaging(staging) {
|
|
391
|
+
const info = await lstat(staging).catch((error) => {
|
|
392
|
+
if (error.code === "ENOENT") return void 0;
|
|
393
|
+
throw error;
|
|
394
|
+
});
|
|
395
|
+
return Boolean(info && info.isDirectory() && !info.isSymbolicLink() && await realpath(staging) === staging);
|
|
396
|
+
}
|
|
397
|
+
function recoveryMarkerMatches(value, keys, expected) {
|
|
398
|
+
return Boolean(value && hasExactKeys(value, keys) && keys.every((key) => value[key] === expected[key]));
|
|
399
|
+
}
|
|
400
|
+
async function helperDirectoryIsKnown(staging, state, gate, requestMayBeAbsent) {
|
|
401
|
+
const helper = join(staging, "helper");
|
|
402
|
+
let entries;
|
|
403
|
+
try {
|
|
404
|
+
entries = await readdir(helper);
|
|
405
|
+
} catch (error) {
|
|
406
|
+
if (error.code === "ENOENT") return requestMayBeAbsent;
|
|
407
|
+
throw error;
|
|
408
|
+
}
|
|
409
|
+
const copiedFiles = /* @__PURE__ */ new Set();
|
|
410
|
+
for (const name of entries) {
|
|
411
|
+
const path = join(helper, name);
|
|
412
|
+
if (name === "bun" || name === "bun.exe" || name === "update-helper.js") {
|
|
413
|
+
const info = await lstat(path);
|
|
414
|
+
if (!info.isFile() || info.isSymbolicLink()) return false;
|
|
415
|
+
copiedFiles.add(name);
|
|
416
|
+
continue;
|
|
417
|
+
}
|
|
418
|
+
const match = /^\.(helper-ready|cancel\.json|cancel-ack\.json)\.([0-9a-f-]{36})\.tmp$/i.exec(name);
|
|
419
|
+
if (!match || !recoveryUuid.test(match[2])) return false;
|
|
420
|
+
let text;
|
|
421
|
+
try {
|
|
422
|
+
text = await readOptionalRecoveryFile(path, 1024);
|
|
423
|
+
} catch {
|
|
424
|
+
return false;
|
|
425
|
+
}
|
|
426
|
+
if (text === void 0) return false;
|
|
427
|
+
let value;
|
|
428
|
+
try {
|
|
429
|
+
value = JSON.parse(text);
|
|
430
|
+
} catch {
|
|
431
|
+
return false;
|
|
432
|
+
}
|
|
433
|
+
if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
|
|
434
|
+
const record = value;
|
|
435
|
+
if (match[1] === "helper-ready") {
|
|
436
|
+
if (!recoveryMarkerMatches(record, [
|
|
437
|
+
"schema",
|
|
438
|
+
"generation",
|
|
439
|
+
"helperOwner",
|
|
440
|
+
"launchGateOwner"
|
|
441
|
+
], {
|
|
442
|
+
schema: 1,
|
|
443
|
+
generation: gate.generation,
|
|
444
|
+
helperOwner: state.helperOwner,
|
|
445
|
+
launchGateOwner: gate.owner
|
|
446
|
+
})) return false;
|
|
447
|
+
} else if (match[1] === "cancel.json") {
|
|
448
|
+
if (!recoveryMarkerMatches(record, [
|
|
449
|
+
"schema",
|
|
450
|
+
"generation",
|
|
451
|
+
"helperOwner"
|
|
452
|
+
], {
|
|
453
|
+
schema: 1,
|
|
454
|
+
generation: gate.generation,
|
|
455
|
+
helperOwner: state.helperOwner
|
|
456
|
+
})) return false;
|
|
457
|
+
} else if (!recoveryMarkerMatches(record, [
|
|
458
|
+
"schema",
|
|
459
|
+
"generation",
|
|
460
|
+
"helperOwner",
|
|
461
|
+
"launchGateOwner"
|
|
462
|
+
], {
|
|
463
|
+
schema: 1,
|
|
464
|
+
generation: gate.generation,
|
|
465
|
+
helperOwner: state.helperOwner,
|
|
466
|
+
launchGateOwner: gate.owner
|
|
467
|
+
})) return false;
|
|
468
|
+
}
|
|
469
|
+
if (requestMayBeAbsent) return true;
|
|
470
|
+
return copiedFiles.has("update-helper.js") && copiedFiles.has("bun") !== copiedFiles.has("bun.exe");
|
|
471
|
+
}
|
|
472
|
+
async function schema3RecoveryArtifactsMatch(target, staging, state, gate, requestMayBeAbsent, trust) {
|
|
473
|
+
if (!await recoveryInventoryIsKnown(staging, state)) return false;
|
|
474
|
+
const verified = state.signedRelease ? verifyReleaseDescriptor(state.signedRelease, trust) : { ok: false };
|
|
475
|
+
if (!verified.ok || verified.descriptor.version !== state.version) return false;
|
|
476
|
+
const requestText = await readOptionalRecoveryFile(join(staging, "request.json"), 65536);
|
|
477
|
+
if (requestText === void 0) {
|
|
478
|
+
if (!requestMayBeAbsent) return false;
|
|
479
|
+
} else try {
|
|
480
|
+
const value = JSON.parse(requestText);
|
|
481
|
+
const request = parseUpdateHelperRequest(value);
|
|
482
|
+
if (typeof value !== "object" || value === null || Array.isArray(value) || !hasExactKeys(value, [
|
|
483
|
+
"schema",
|
|
484
|
+
"target",
|
|
485
|
+
"platform",
|
|
486
|
+
"version",
|
|
487
|
+
"processes",
|
|
488
|
+
"processTimeoutMs",
|
|
489
|
+
"generation",
|
|
490
|
+
"helperOwner"
|
|
491
|
+
]) || request.schema !== 3 || request.target !== target || request.generation !== gate.generation || request.version !== gate.version || request.helperOwner !== state.helperOwner || !requestPlatformMatchesTrust(request.platform, trust)) return false;
|
|
492
|
+
} catch {
|
|
493
|
+
return false;
|
|
494
|
+
}
|
|
495
|
+
const armedText = await readOptionalRecoveryFile(join(staging, "helper-armed"), 64);
|
|
496
|
+
if (armedText !== void 0 && (!/^\d+\s*$/.test(armedText) || Number(armedText.trim()) !== state.helperPid)) return false;
|
|
497
|
+
const markers = [
|
|
498
|
+
{
|
|
499
|
+
name: "helper-ready",
|
|
500
|
+
keys: [
|
|
501
|
+
"schema",
|
|
502
|
+
"generation",
|
|
503
|
+
"helperOwner",
|
|
504
|
+
"launchGateOwner"
|
|
505
|
+
],
|
|
506
|
+
values: {
|
|
507
|
+
schema: 1,
|
|
508
|
+
generation: gate.generation,
|
|
509
|
+
helperOwner: state.helperOwner,
|
|
510
|
+
launchGateOwner: gate.owner
|
|
511
|
+
}
|
|
512
|
+
},
|
|
513
|
+
{
|
|
514
|
+
name: "cancel.json",
|
|
515
|
+
keys: [
|
|
516
|
+
"schema",
|
|
517
|
+
"generation",
|
|
518
|
+
"helperOwner"
|
|
519
|
+
],
|
|
520
|
+
values: {
|
|
521
|
+
schema: 1,
|
|
522
|
+
generation: gate.generation,
|
|
523
|
+
helperOwner: state.helperOwner
|
|
524
|
+
}
|
|
525
|
+
},
|
|
526
|
+
{
|
|
527
|
+
name: "cancel-ack.json",
|
|
528
|
+
keys: [
|
|
529
|
+
"schema",
|
|
530
|
+
"generation",
|
|
531
|
+
"helperOwner",
|
|
532
|
+
"launchGateOwner"
|
|
533
|
+
],
|
|
534
|
+
values: {
|
|
535
|
+
schema: 1,
|
|
536
|
+
generation: gate.generation,
|
|
537
|
+
helperOwner: state.helperOwner,
|
|
538
|
+
launchGateOwner: gate.owner
|
|
539
|
+
}
|
|
540
|
+
}
|
|
541
|
+
];
|
|
542
|
+
for (const marker of markers) {
|
|
543
|
+
let value;
|
|
544
|
+
try {
|
|
545
|
+
value = await readUpdateMarker(staging, marker.name);
|
|
546
|
+
} catch {
|
|
547
|
+
return false;
|
|
548
|
+
}
|
|
549
|
+
if (value === void 0) continue;
|
|
550
|
+
if (!recoveryMarkerMatches(value, marker.keys, marker.values)) return false;
|
|
551
|
+
}
|
|
552
|
+
return helperDirectoryIsKnown(staging, state, gate, requestMayBeAbsent);
|
|
553
|
+
}
|
|
554
|
+
function requestPlatformMatchesTrust(platform, trust) {
|
|
555
|
+
return platform === "macos-arm64" && trust.platform === "darwin" && trust.arch === "arm64" || platform === "windows-x64" && trust.platform === "win32" && trust.arch === "x64" || platform === "linux-x64" && trust.platform === "linux" && trust.arch === "x64";
|
|
556
|
+
}
|
|
557
|
+
async function schema3TreeLayout(target, staging, state) {
|
|
558
|
+
if (!state.candidateTreeIdentity || !state.candidateTreeDigest || !state.previousTreeIdentity) return void 0;
|
|
559
|
+
const candidate = join(staging, "candidate");
|
|
560
|
+
const [targetInfo, candidateInfo] = await Promise.all([lstat(target).catch((error) => {
|
|
561
|
+
if (error.code === "ENOENT") return void 0;
|
|
562
|
+
throw error;
|
|
563
|
+
}), lstat(candidate).catch((error) => {
|
|
564
|
+
if (error.code === "ENOENT") return void 0;
|
|
565
|
+
throw error;
|
|
566
|
+
})]);
|
|
567
|
+
if (!targetInfo || !targetInfo.isDirectory() || targetInfo.isSymbolicLink() || !candidateInfo || !candidateInfo.isDirectory() || candidateInfo.isSymbolicLink()) return void 0;
|
|
568
|
+
const [targetVersion, candidateVersion, targetIdentity, candidateIdentity] = await Promise.all([
|
|
569
|
+
readUpdateTreeVersion(target),
|
|
570
|
+
readUpdateTreeVersion(candidate),
|
|
571
|
+
readUpdateTreeIdentity(target),
|
|
572
|
+
readUpdateTreeIdentity(candidate)
|
|
573
|
+
]);
|
|
574
|
+
if (!targetIdentity || !candidateIdentity || sameUpdateTreeIdentity(targetIdentity, candidateIdentity)) return void 0;
|
|
575
|
+
if (targetVersion === state.previousVersion && candidateVersion === state.version && sameUpdateTreeIdentity(targetIdentity, state.previousTreeIdentity) && sameUpdateTreeIdentity(candidateIdentity, state.candidateTreeIdentity)) return sameUpdateTreeDigest(await readTreeDigestForProof(candidate), state.candidateTreeDigest) ? "pre-swap" : void 0;
|
|
576
|
+
if (targetVersion === state.version && candidateVersion === state.previousVersion && sameUpdateTreeIdentity(targetIdentity, state.candidateTreeIdentity) && sameUpdateTreeIdentity(candidateIdentity, state.previousTreeIdentity)) return sameUpdateTreeDigest(await readTreeDigestForProof(target), state.candidateTreeDigest) ? "post-swap" : void 0;
|
|
577
|
+
}
|
|
578
|
+
function schema3JournalMatchesGate(state, gate) {
|
|
579
|
+
return Boolean(state && state.schema === 1 && [
|
|
580
|
+
"armed",
|
|
581
|
+
"swapping",
|
|
582
|
+
"completed",
|
|
583
|
+
"staged"
|
|
584
|
+
].includes(state.phase) && state.generation === gate.generation && state.version === gate.version && state.launchGateOwner === gate.owner && typeof state.helperOwner === "string" && recoveryUuid.test(state.helperOwner) && Number.isSafeInteger(state.helperPid) && (state.helperPid ?? 0) >= 2 && recoveryUuid.test(state.generation) && state.version !== state.previousVersion && state.candidateTreeIdentity !== void 0 && state.candidateTreeDigest !== void 0 && state.previousTreeIdentity !== void 0);
|
|
585
|
+
}
|
|
586
|
+
async function removeSchema3HelperArtifacts(staging) {
|
|
587
|
+
for (const name of [
|
|
588
|
+
"request.json",
|
|
589
|
+
"helper-armed",
|
|
590
|
+
"helper-ready",
|
|
591
|
+
"cancel.json",
|
|
592
|
+
"cancel-ack.json"
|
|
593
|
+
]) await rm(join(staging, name), { force: true });
|
|
594
|
+
const state = await readUpdateStageState(staging);
|
|
595
|
+
if (!state) throw new Error("Schema-3 recovery journal disappeared");
|
|
596
|
+
const stateTemporary = new RegExp(`^\\.state-${state.generation}-[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}\\.tmp$`, "i");
|
|
597
|
+
for (const name of await readdir(staging)) {
|
|
598
|
+
if (!stateTemporary.test(name)) continue;
|
|
599
|
+
const path = join(staging, name);
|
|
600
|
+
const info = await lstat(path);
|
|
601
|
+
if (!info.isFile() || info.isSymbolicLink() || info.size > 4096) throw new Error("Invalid schema-3 journal temporary");
|
|
602
|
+
await unlink(path);
|
|
603
|
+
}
|
|
604
|
+
await rm(join(staging, "helper"), {
|
|
26
605
|
recursive: true,
|
|
27
606
|
force: true
|
|
28
607
|
});
|
|
29
|
-
return version ? {
|
|
30
|
-
status: "updated",
|
|
31
|
-
version
|
|
32
|
-
} : { status: "not-applied" };
|
|
33
608
|
}
|
|
34
|
-
|
|
609
|
+
async function finalizationTemporaries(staging, state) {
|
|
610
|
+
const names = await readdir(staging);
|
|
611
|
+
const stateTemporary = new RegExp(`^\\.state-${state.generation}-[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}\\.tmp$`, "i");
|
|
612
|
+
const temporaryNames = [];
|
|
613
|
+
for (const name of names) {
|
|
614
|
+
if (name === "candidate" || name === "state.json") {
|
|
615
|
+
const info = await lstat(join(staging, name));
|
|
616
|
+
if (name === "candidate" ? !info.isDirectory() || info.isSymbolicLink() : !info.isFile() || info.isSymbolicLink()) return void 0;
|
|
617
|
+
continue;
|
|
618
|
+
}
|
|
619
|
+
if (!stateTemporary.test(name)) return void 0;
|
|
620
|
+
const path = join(staging, name);
|
|
621
|
+
const info = await lstat(path);
|
|
622
|
+
if (!info.isFile() || info.isSymbolicLink() || info.size > 4096) return void 0;
|
|
623
|
+
temporaryNames.push(name);
|
|
624
|
+
}
|
|
625
|
+
if (!names.includes("candidate") || !names.includes("state.json")) return void 0;
|
|
626
|
+
return temporaryNames;
|
|
627
|
+
}
|
|
628
|
+
async function removeFinalizationTemporaries(staging, names) {
|
|
629
|
+
for (const name of names) {
|
|
630
|
+
const path = join(staging, name);
|
|
631
|
+
const info = await lstat(path);
|
|
632
|
+
if (!info.isFile() || info.isSymbolicLink() || info.size > 4096) throw new Error("Invalid update journal temporary");
|
|
633
|
+
await unlink(path);
|
|
634
|
+
}
|
|
635
|
+
}
|
|
636
|
+
async function ownerlessStagedTreeMatches(target, staging, state) {
|
|
637
|
+
if (!state.candidateTreeIdentity || !state.candidateTreeDigest) return false;
|
|
638
|
+
const candidate = join(staging, "candidate");
|
|
639
|
+
const [targetInfo, candidateInfo] = await Promise.all([lstat(target).catch((error) => {
|
|
640
|
+
if (error.code === "ENOENT") return void 0;
|
|
641
|
+
throw error;
|
|
642
|
+
}), lstat(candidate).catch((error) => {
|
|
643
|
+
if (error.code === "ENOENT") return void 0;
|
|
644
|
+
throw error;
|
|
645
|
+
})]);
|
|
646
|
+
if (!targetInfo || !targetInfo.isDirectory() || targetInfo.isSymbolicLink() || !candidateInfo || !candidateInfo.isDirectory() || candidateInfo.isSymbolicLink()) return false;
|
|
647
|
+
const [targetVersion, candidateVersion, targetIdentity, candidateIdentity] = await Promise.all([
|
|
648
|
+
readUpdateTreeVersion(target),
|
|
649
|
+
readUpdateTreeVersion(candidate),
|
|
650
|
+
readUpdateTreeIdentity(target),
|
|
651
|
+
readUpdateTreeIdentity(candidate)
|
|
652
|
+
]);
|
|
653
|
+
const candidateDigest = await readTreeDigestForProof(candidate);
|
|
654
|
+
return Boolean(targetVersion === state.previousVersion && candidateVersion === state.version && targetIdentity && candidateIdentity && !sameUpdateTreeIdentity(targetIdentity, candidateIdentity) && sameUpdateTreeIdentity(candidateIdentity, state.candidateTreeIdentity) && sameUpdateTreeDigest(candidateDigest, state.candidateTreeDigest) && (!state.previousTreeIdentity || sameUpdateTreeIdentity(targetIdentity, state.previousTreeIdentity)));
|
|
655
|
+
}
|
|
656
|
+
/**
|
|
657
|
+
* Reconcile only the schema-3 journal bound to the exact persisted gate. The
|
|
658
|
+
* caller deliberately opts into this operation; generated unmanaged startup
|
|
659
|
+
* reaches it through `recoverPackagedUpdateLaunchGate` before launch admission.
|
|
660
|
+
*/
|
|
661
|
+
async function recoverUpdateLaunchGate(target, trust) {
|
|
662
|
+
const staging = updateStagingFor(target);
|
|
663
|
+
const result = await tryRecoverUpdateLaunchGate(target, async (gate) => {
|
|
664
|
+
if (!await isCanonicalRecoveryStaging(staging)) return false;
|
|
665
|
+
const state = await readUpdateStageState(staging);
|
|
666
|
+
if (!schema3JournalMatchesGate(state, gate)) return false;
|
|
667
|
+
const requestMayBeAbsent = state.phase === "staged" || state.phase === "completed";
|
|
668
|
+
if (!await schema3RecoveryArtifactsMatch(target, staging, state, gate, requestMayBeAbsent, trust)) return false;
|
|
669
|
+
const layout = await schema3TreeLayout(target, staging, state);
|
|
670
|
+
if (!layout) return false;
|
|
671
|
+
if (state.phase === "armed" && layout !== "pre-swap" || state.phase === "completed" && layout !== "post-swap" || state.phase === "staged" && layout !== "pre-swap") return false;
|
|
672
|
+
const nextPhase = state.phase === "completed" || state.phase === "swapping" && layout === "post-swap" ? "completed" : "staged";
|
|
673
|
+
const reconciled = {
|
|
674
|
+
...state,
|
|
675
|
+
phase: nextPhase
|
|
676
|
+
};
|
|
677
|
+
await syncUpdateTreeParent(target);
|
|
678
|
+
await syncUpdateTreeParent(join(staging, "candidate"));
|
|
679
|
+
await writeUpdateStageStateDurably(staging, reconciled);
|
|
680
|
+
await removeSchema3HelperArtifacts(staging);
|
|
681
|
+
const entries = await readdir(staging);
|
|
682
|
+
if (entries.length !== 2 || !entries.includes("candidate") || !entries.includes("state.json")) return false;
|
|
683
|
+
const current = await readUpdateStageState(staging);
|
|
684
|
+
if (!schema3JournalMatchesGate(current, gate) || current.phase !== reconciled.phase || !sameUpdateTreeIdentity(await readUpdateTreeIdentity(target), layout === "post-swap" ? current.candidateTreeIdentity : current.previousTreeIdentity) || !sameUpdateTreeIdentity(await readUpdateTreeIdentity(join(staging, "candidate")), layout === "post-swap" ? current.previousTreeIdentity : current.candidateTreeIdentity)) return false;
|
|
685
|
+
await writeUpdateStageStateDurably(staging, reconciled);
|
|
686
|
+
return true;
|
|
687
|
+
});
|
|
688
|
+
if (result !== "absent" && result !== "recovered") return result;
|
|
689
|
+
const finalized = await finalizeClearedSchema3StagedOwner(target, staging, trust);
|
|
690
|
+
if (finalized === "absent") return result;
|
|
691
|
+
return finalized;
|
|
692
|
+
}
|
|
693
|
+
async function finalizeClearedSchema3StagedOwner(target, staging, trust) {
|
|
694
|
+
const instance = await tryAcquireUpdateInstanceLease(target, "exclusive");
|
|
695
|
+
if (!instance) return "busy";
|
|
696
|
+
let lock;
|
|
697
|
+
let helper;
|
|
698
|
+
try {
|
|
699
|
+
lock = await tryAcquireUpdateLock(target);
|
|
700
|
+
if (!lock) return "busy";
|
|
701
|
+
if (await readUpdateLaunchGate(target)) return "unreconciled";
|
|
702
|
+
helper = await tryAcquireUpdateHelperLiveness(target);
|
|
703
|
+
if (!helper) return "helper-live";
|
|
704
|
+
await syncUpdateTreeParent(target);
|
|
705
|
+
if (!await lstat(staging).catch((error) => {
|
|
706
|
+
if (error.code === "ENOENT") return void 0;
|
|
707
|
+
throw error;
|
|
708
|
+
})) return "absent";
|
|
709
|
+
if (!await isCanonicalRecoveryStaging(staging)) return "unreconciled";
|
|
710
|
+
const state = await readUpdateStageState(staging);
|
|
711
|
+
if (!state || state.phase !== "staged" && state.phase !== "completed") return "absent";
|
|
712
|
+
if (!state.launchGateOwner) {
|
|
713
|
+
if (state.helperPid !== void 0 || state.helperOwner !== void 0) return "unreconciled";
|
|
714
|
+
const verified = state.signedRelease ? verifyReleaseDescriptor(state.signedRelease, trust) : { ok: false };
|
|
715
|
+
if (!verified.ok || verified.descriptor.version !== state.version) return "absent";
|
|
716
|
+
const temporaries = await finalizationTemporaries(staging, state);
|
|
717
|
+
if (!temporaries) return "unreconciled";
|
|
718
|
+
if (!(state.phase === "staged" ? await ownerlessStagedTreeMatches(target, staging, state) : await schema3TreeLayout(target, staging, state) === "post-swap")) return "unreconciled";
|
|
719
|
+
await syncUpdateTreeParent(target);
|
|
720
|
+
await syncUpdateTreeParent(join(staging, "candidate"));
|
|
721
|
+
await removeFinalizationTemporaries(staging, temporaries);
|
|
722
|
+
await syncUpdateStageDirectory(staging);
|
|
723
|
+
return "absent";
|
|
724
|
+
}
|
|
725
|
+
if (!recoveryUuid.test(state.generation) || !recoveryUuid.test(state.launchGateOwner) || !recoveryUuid.test(state.helperOwner ?? "") || !Number.isSafeInteger(state.helperPid) || (state.helperPid ?? 0) < 2) return "unreconciled";
|
|
726
|
+
const verified = state.signedRelease ? verifyReleaseDescriptor(state.signedRelease, trust) : { ok: false };
|
|
727
|
+
if (!verified.ok || verified.descriptor.version !== state.version) return "unreconciled";
|
|
728
|
+
const temporaries = await finalizationTemporaries(staging, state);
|
|
729
|
+
if (!temporaries) return "unreconciled";
|
|
730
|
+
const info = await lstat(join(staging, "candidate"));
|
|
731
|
+
if (!info.isDirectory() || info.isSymbolicLink()) return "unreconciled";
|
|
732
|
+
const layout = await schema3TreeLayout(target, staging, state);
|
|
733
|
+
if (state.phase === "staged" && layout !== "pre-swap" || state.phase === "completed" && layout !== "post-swap") return "unreconciled";
|
|
734
|
+
await syncUpdateTreeParent(join(staging, "candidate"));
|
|
735
|
+
await removeFinalizationTemporaries(staging, temporaries);
|
|
736
|
+
const { helperPid: _helperPid, helperOwner: _helperOwner, launchGateOwner: _launchGateOwner, previousTreeIdentity: _previousTreeIdentity, ...stagedRecoverable } = state;
|
|
737
|
+
const { helperPid: _completedHelperPid, helperOwner: _completedHelperOwner, launchGateOwner: _completedLaunchGateOwner, ...completedRecoverable } = state;
|
|
738
|
+
await writeUpdateStageStateDurably(staging, state.phase === "staged" ? {
|
|
739
|
+
...stagedRecoverable,
|
|
740
|
+
phase: "staged"
|
|
741
|
+
} : {
|
|
742
|
+
...completedRecoverable,
|
|
743
|
+
phase: "completed"
|
|
744
|
+
});
|
|
745
|
+
return "recovered";
|
|
746
|
+
} finally {
|
|
747
|
+
try {
|
|
748
|
+
await helper?.release();
|
|
749
|
+
} finally {
|
|
750
|
+
try {
|
|
751
|
+
await lock?.release();
|
|
752
|
+
} finally {
|
|
753
|
+
await instance.release();
|
|
754
|
+
}
|
|
755
|
+
}
|
|
756
|
+
}
|
|
757
|
+
}
|
|
758
|
+
/**
|
|
759
|
+
* Call on app start. Reconcile only while holding the same per-install lock
|
|
760
|
+
* used by stage, helper handoff, and the swap. A valid staged candidate is
|
|
761
|
+
* retained until a helper completes or an explicit caller handles it.
|
|
762
|
+
*/
|
|
763
|
+
async function resumeUpdate(options) {
|
|
764
|
+
const staging = updateStagingFor(options.target);
|
|
765
|
+
let lock;
|
|
766
|
+
try {
|
|
767
|
+
lock = await acquireUpdateLock(options.target, 100);
|
|
768
|
+
} catch (error) {
|
|
769
|
+
if (error instanceof UpdateLockBusyError) return { status: "in-progress" };
|
|
770
|
+
throw error;
|
|
771
|
+
}
|
|
772
|
+
try {
|
|
773
|
+
return await resumeLocked({
|
|
774
|
+
target: options.target,
|
|
775
|
+
staging,
|
|
776
|
+
trust: options.trust,
|
|
777
|
+
currentVersion: options.currentVersion
|
|
778
|
+
});
|
|
779
|
+
} finally {
|
|
780
|
+
await lock.release();
|
|
781
|
+
}
|
|
782
|
+
}
|
|
783
|
+
/**
|
|
784
|
+
* Resume and acquire retained-generation leases under one install lock. This
|
|
785
|
+
* lets callers with explicit release trust serve old lazy assets alongside a
|
|
786
|
+
* validated pending staged candidate without opening a swap race.
|
|
787
|
+
*/
|
|
788
|
+
async function resumeUpdateWithRetainedTrees(options) {
|
|
789
|
+
const staging = updateStagingFor(options.target);
|
|
790
|
+
let lock;
|
|
791
|
+
try {
|
|
792
|
+
lock = await acquireUpdateLock(options.target, 100);
|
|
793
|
+
} catch (error) {
|
|
794
|
+
if (error instanceof UpdateLockBusyError) return { status: "in-progress" };
|
|
795
|
+
throw error;
|
|
796
|
+
}
|
|
797
|
+
let retained;
|
|
798
|
+
try {
|
|
799
|
+
if ((await readUpdateStageState(staging))?.phase === "armed") return { status: "recovery-required" };
|
|
800
|
+
const resumed = await resumeLocked({
|
|
801
|
+
target: options.target,
|
|
802
|
+
staging,
|
|
803
|
+
trust: options.trust,
|
|
804
|
+
currentVersion: options.currentVersion
|
|
805
|
+
});
|
|
806
|
+
if (resumed.status === "in-progress" || resumed.status === "recovery-required") return { status: resumed.status };
|
|
807
|
+
retained = await acquireRetainedUpdateTreesWhileLocked({
|
|
808
|
+
target: options.target,
|
|
809
|
+
currentVersion: resumed.status === "updated" ? resumed.version : options.currentVersion,
|
|
810
|
+
...resumed.status === "staged" ? {
|
|
811
|
+
validatedStagedVersion: resumed.version,
|
|
812
|
+
stagedTrust: options.trust
|
|
813
|
+
} : {}
|
|
814
|
+
});
|
|
815
|
+
if (retained.status === "busy") return { status: "busy" };
|
|
816
|
+
const result = {
|
|
817
|
+
status: "ready",
|
|
818
|
+
resume: resumed,
|
|
819
|
+
retained
|
|
820
|
+
};
|
|
821
|
+
const heldLock = lock;
|
|
822
|
+
lock = void 0;
|
|
823
|
+
try {
|
|
824
|
+
await heldLock.release();
|
|
825
|
+
} catch (error) {
|
|
826
|
+
if (retained.status === "acquired") {
|
|
827
|
+
const acquired = retained;
|
|
828
|
+
retained = void 0;
|
|
829
|
+
try {
|
|
830
|
+
await acquired.release();
|
|
831
|
+
} catch (releaseError) {
|
|
832
|
+
throw new AggregateError([error, releaseError], "Update lock and retained tree leases failed to release", { cause: releaseError });
|
|
833
|
+
}
|
|
834
|
+
}
|
|
835
|
+
throw error;
|
|
836
|
+
}
|
|
837
|
+
retained = void 0;
|
|
838
|
+
return result;
|
|
839
|
+
} catch (error) {
|
|
840
|
+
if (retained?.status === "acquired") try {
|
|
841
|
+
await retained.release();
|
|
842
|
+
} catch (releaseError) {
|
|
843
|
+
throw new AggregateError([error, releaseError], "Resume failure and retained tree leases failed to release", { cause: releaseError });
|
|
844
|
+
}
|
|
845
|
+
throw error;
|
|
846
|
+
} finally {
|
|
847
|
+
await lock?.release();
|
|
848
|
+
}
|
|
849
|
+
}
|
|
850
|
+
export { acquireRetainedUpdateTrees, recoverUpdateLaunchGate, resumeUpdate, resumeUpdateWithRetainedTrees };
|