@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.
Files changed (138) hide show
  1. package/README.md +183 -17
  2. package/dist/app/create-application.d.ts +2 -0
  3. package/dist/app/create-application.js +6 -0
  4. package/dist/app/service-registry.js +4 -0
  5. package/dist/appearance/custom-theme-import.js +43 -7
  6. package/dist/appearance/custom-theme-library.d.ts +2 -0
  7. package/dist/appearance/custom-theme-library.js +5 -1
  8. package/dist/appearance/theme-record-adapter.js +4 -2
  9. package/dist/appearance/theme-registry.js +7 -1
  10. package/dist/cli/cef-helper-cli.js +0 -0
  11. package/dist/cli/create-application-cli.js +4 -2
  12. package/dist/cli/electrobun-shortcut-patch-cli.js +0 -0
  13. package/dist/cli/framework-update-cli.js +0 -0
  14. package/dist/cli/macos-signing-cli.js +0 -0
  15. package/dist/cli/release-assets-plan-cli.js +0 -0
  16. package/dist/cli/release-cut-cli.js +0 -0
  17. package/dist/cli/release-descriptor-staging-cli.js +0 -0
  18. package/dist/cli/release-finalize-cli.js +0 -0
  19. package/dist/cli/release-promote-cli.js +0 -0
  20. package/dist/cli/release-publish-cli.js +0 -0
  21. package/dist/cli/release-sign-cli.js +0 -0
  22. package/dist/cli/release-step-cli.js +6 -1
  23. package/dist/cli/toolchain-identity-cli.js +0 -0
  24. package/dist/cli/update-helper-cli.js +28 -6
  25. package/dist/cli/windows-runtime-patch-cli.js +0 -0
  26. package/dist/desktop/client-asset-manifest.d.ts +47 -0
  27. package/dist/desktop/client-asset-manifest.js +114 -0
  28. package/dist/desktop/client-asset-stream.d.ts +10 -0
  29. package/dist/desktop/client-asset-stream.js +138 -33
  30. package/dist/desktop/client-assets.d.ts +20 -0
  31. package/dist/desktop/client-assets.js +132 -22
  32. package/dist/desktop/client-response-lifecycle.d.ts +22 -0
  33. package/dist/desktop/client-response-lifecycle.js +233 -0
  34. package/dist/desktop/desktop-host.d.ts +40 -2
  35. package/dist/desktop/desktop-host.js +159 -9
  36. package/dist/framework-source.json +1 -1
  37. package/dist/installer/command-artifact.d.ts +4 -2
  38. package/dist/installer/command-artifact.js +119 -19
  39. package/dist/installer/installer-identity.d.ts +4 -1
  40. package/dist/installer/installer-identity.js +6 -3
  41. package/dist/installer/installer-layout.d.ts +2 -0
  42. package/dist/installer/installer-layout.js +5 -1
  43. package/dist/installer/linux-process-group.d.ts +13 -0
  44. package/dist/installer/linux-process-group.js +58 -0
  45. package/dist/native/darwin-sync.d.ts +7 -0
  46. package/dist/native/darwin-sync.js +43 -0
  47. package/dist/native/desktop-build-hook.js +7 -0
  48. package/dist/native/directory-exchange.d.ts +10 -0
  49. package/dist/native/directory-exchange.js +90 -0
  50. package/dist/native/electrobun-source-patch.d.ts +5 -0
  51. package/dist/native/electrobun-source-patch.js +19 -1
  52. package/dist/native/posix-launcher-build.d.ts +24 -0
  53. package/dist/native/posix-launcher-build.js +232 -0
  54. package/dist/native/posix-tree-removal.d.ts +36 -0
  55. package/dist/native/posix-tree-removal.js +425 -0
  56. package/dist/release/release-steps.d.ts +5 -0
  57. package/dist/release/release-steps.js +2 -1
  58. package/dist/update-helper.bundle.js +1483 -105
  59. package/dist/updates/channel-update-manager.d.ts +5 -0
  60. package/dist/updates/channel-update-manager.js +13 -1
  61. package/dist/updates/desktop-updater.d.ts +78 -2
  62. package/dist/updates/desktop-updater.js +320 -37
  63. package/dist/updates/launch-environment.d.ts +2 -0
  64. package/dist/updates/launch-environment.js +4 -0
  65. package/dist/updates/native-file-lock.d.ts +15 -0
  66. package/dist/updates/native-file-lock.js +189 -0
  67. package/dist/updates/packaged-launch-admission.d.ts +13 -0
  68. package/dist/updates/packaged-launch-admission.js +45 -0
  69. package/dist/updates/packaged-release-config.d.ts +18 -0
  70. package/dist/updates/packaged-release-config.js +60 -0
  71. package/dist/updates/packaged-update-startup.d.ts +44 -0
  72. package/dist/updates/packaged-update-startup.js +81 -0
  73. package/dist/updates/update-arm.d.ts +9 -8
  74. package/dist/updates/update-arm.js +227 -62
  75. package/dist/updates/update-cleanup-error.d.ts +23 -0
  76. package/dist/updates/update-cleanup-error.js +65 -0
  77. package/dist/updates/update-download-cleanup.d.ts +11 -0
  78. package/dist/updates/update-download-cleanup.js +112 -2
  79. package/dist/updates/update-download-lock.d.ts +20 -0
  80. package/dist/updates/update-download-lock.js +73 -0
  81. package/dist/updates/update-download.d.ts +2 -0
  82. package/dist/updates/update-download.js +7 -3
  83. package/dist/updates/update-generation-lease.d.ts +6 -0
  84. package/dist/updates/update-generation-lease.js +14 -0
  85. package/dist/updates/update-helper.d.ts +11 -2
  86. package/dist/updates/update-helper.js +322 -13
  87. package/dist/updates/update-inherited-launch-lease.d.ts +22 -0
  88. package/dist/updates/update-inherited-launch-lease.js +58 -0
  89. package/dist/updates/update-instance-lease.d.ts +15 -0
  90. package/dist/updates/update-instance-lease.js +25 -0
  91. package/dist/updates/update-launch-gate.d.ts +137 -0
  92. package/dist/updates/update-launch-gate.js +617 -0
  93. package/dist/updates/update-launch.js +3 -1
  94. package/dist/updates/update-lock.d.ts +12 -0
  95. package/dist/updates/update-lock.js +18 -0
  96. package/dist/updates/update-manager.d.ts +2 -0
  97. package/dist/updates/update-manager.js +9 -2
  98. package/dist/updates/update-marker.d.ts +7 -0
  99. package/dist/updates/update-marker.js +62 -0
  100. package/dist/updates/update-preflight-error.d.ts +7 -0
  101. package/dist/updates/update-preflight-error.js +11 -0
  102. package/dist/updates/update-process-fence.d.ts +4 -0
  103. package/dist/updates/update-process-fence.js +85 -73
  104. package/dist/updates/update-process-liveness.d.ts +2 -0
  105. package/dist/updates/update-process-liveness.js +11 -0
  106. package/dist/updates/update-resume.d.ts +37 -3
  107. package/dist/updates/update-resume.js +839 -23
  108. package/dist/updates/update-retention-marker.d.ts +67 -0
  109. package/dist/updates/update-retention-marker.js +165 -0
  110. package/dist/updates/update-retention-plan.d.ts +25 -0
  111. package/dist/updates/update-retention-plan.js +54 -0
  112. package/dist/updates/update-retention-sync.d.ts +34 -0
  113. package/dist/updates/update-retention-sync.js +83 -0
  114. package/dist/updates/update-retirement.d.ts +205 -0
  115. package/dist/updates/update-retirement.js +1485 -0
  116. package/dist/updates/update-shutdown.d.ts +16 -4
  117. package/dist/updates/update-shutdown.js +133 -8
  118. package/dist/updates/update-state-store.d.ts +58 -0
  119. package/dist/updates/update-state-store.js +139 -0
  120. package/dist/updates/update-swap-stage.d.ts +1 -1
  121. package/dist/updates/update-swap-stage.js +85 -14
  122. package/dist/updates/update-swap.d.ts +45 -2
  123. package/dist/updates/update-swap.js +207 -17
  124. package/package.json +31 -1
  125. package/src/appearance/custom-theme-import.ts +96 -14
  126. package/src/appearance/custom-theme-library.ts +5 -0
  127. package/src/appearance/theme-record-adapter.ts +15 -6
  128. package/src/appearance/theme-registry.ts +8 -1
  129. package/src/desktop/client-asset-manifest.ts +207 -0
  130. package/src/desktop/client-asset-stream.ts +193 -32
  131. package/src/desktop/client-assets.ts +210 -19
  132. package/src/desktop/client-response-lifecycle.ts +305 -0
  133. package/src/native/electrobun-posix-launch-lease.patch +398 -0
  134. package/templates/application/README.md +50 -0
  135. package/templates/application/electrobun.config.ts +5 -1
  136. package/templates/application/scripts/build-desktop.ts +4 -0
  137. package/templates/application/src/bun/index.ts +173 -16
  138. package/templates/application/vite.config.ts +112 -6
@@ -1,30 +1,97 @@
1
1
  // @bun
2
2
  // src/updates/update-helper.ts
3
- import { constants, writeFileSync } from "fs";
4
- import { lstat, open, writeFile } from "fs/promises";
5
- import { isAbsolute as isAbsolute5, join as join3, resolve as resolve4 } from "path";
3
+ import { constants as constants6 } from "fs";
4
+ import { lstat as lstat4, open as open6, realpath as realpath2 } from "fs/promises";
5
+ import { isAbsolute as isAbsolute8, join as join9, resolve as resolve7 } from "path";
6
+
7
+ // src/updates/update-marker.ts
8
+ import { randomUUID } from "crypto";
9
+ import { closeSync, constants, linkSync, openSync, unlinkSync, writeFileSync } from "fs";
10
+ import { link, open, unlink, writeFile } from "fs/promises";
11
+ import { join } from "path";
12
+ function publishExclusiveUpdateMarkerSync(staging, name, value) {
13
+ const marker = join(staging, name);
14
+ const temporary = join(staging, "helper", `.${name}.${randomUUID()}.tmp`);
15
+ let descriptor;
16
+ try {
17
+ descriptor = openSync(temporary, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL, 384);
18
+ writeFileSync(descriptor, JSON.stringify(value) + `
19
+ `);
20
+ closeSync(descriptor);
21
+ descriptor = undefined;
22
+ linkSync(temporary, marker);
23
+ } finally {
24
+ if (descriptor !== undefined) {
25
+ try {
26
+ closeSync(descriptor);
27
+ } catch {}
28
+ }
29
+ try {
30
+ unlinkSync(temporary);
31
+ } catch {}
32
+ }
33
+ }
34
+ async function publishExclusiveUpdateMarker(staging, name, value) {
35
+ const marker = join(staging, name);
36
+ const temporary = join(staging, "helper", `.${name}.${randomUUID()}.tmp`);
37
+ try {
38
+ await writeFile(temporary, JSON.stringify(value) + `
39
+ `, { flag: "wx", mode: 384 });
40
+ await link(temporary, marker);
41
+ } finally {
42
+ await unlink(temporary).catch(() => {});
43
+ }
44
+ }
45
+ async function readUpdateMarker(staging, name) {
46
+ const path = join(staging, name);
47
+ let file;
48
+ try {
49
+ file = await open(path, constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0));
50
+ } catch (error) {
51
+ if (error.code === "ENOENT")
52
+ return;
53
+ throw error;
54
+ }
55
+ try {
56
+ const info = await file.stat();
57
+ if (!info.isFile() || info.size < 1 || info.size > 1024)
58
+ throw new Error(`Invalid ${name} marker`);
59
+ const value = JSON.parse(await file.readFile("utf8"));
60
+ if (typeof value !== "object" || value === null || Array.isArray(value))
61
+ throw new Error(`Invalid ${name} marker`);
62
+ return value;
63
+ } finally {
64
+ await file.close();
65
+ }
66
+ }
6
67
 
7
68
  // src/updates/update-launch.ts
8
69
  import { spawn } from "child_process";
9
- import { dirname, isAbsolute, join, resolve } from "path";
70
+ import { dirname, isAbsolute, join as join2, resolve } from "path";
71
+
72
+ // src/updates/launch-environment.ts
73
+ var INHERITED_LAUNCH_LEASE_ENV = "ADEA_INHERITED_LAUNCH_LEASE_FD";
74
+
75
+ // src/updates/update-launch.ts
10
76
  function updateLauncherPath(platform, target) {
11
77
  if (typeof target !== "string" || !isAbsolute(target) || resolve(target) !== target)
12
78
  throw new Error("Invalid update target");
13
79
  if (platform === "macos-arm64")
14
- return join(target, "Contents", "MacOS", "launcher");
80
+ return join2(target, "Contents", "MacOS", "launcher");
15
81
  if (platform === "windows-x64")
16
- return join(target, "bin", "launcher.exe");
82
+ return join2(target, "bin", "launcher.exe");
17
83
  if (platform === "linux-x64")
18
- return join(target, "bin", "launcher");
84
+ return join2(target, "bin", "launcher");
19
85
  throw new Error("Unsupported update platform");
20
86
  }
21
87
  async function launchInstalledApp(platform, target, env = process.env) {
22
88
  const executable = updateLauncherPath(platform, target);
89
+ const childEnv = Object.fromEntries(Object.entries(env).filter(([key]) => key.toUpperCase() !== INHERITED_LAUNCH_LEASE_ENV));
23
90
  const child = spawn(executable, [], {
24
91
  cwd: dirname(executable),
25
92
  detached: true,
26
93
  stdio: "ignore",
27
- env
94
+ env: childEnv
28
95
  });
29
96
  await new Promise((done, reject) => {
30
97
  child.once("spawn", done);
@@ -34,11 +101,9 @@ async function launchInstalledApp(platform, target, env = process.env) {
34
101
  }
35
102
 
36
103
  // src/updates/update-process-fence.ts
37
- import { execFile } from "child_process";
38
104
  import { dlopen, FFIType, ptr } from "bun:ffi";
39
105
  import { readFile, realpath } from "fs/promises";
40
106
  import { isAbsolute as isAbsolute2 } from "path";
41
- import { promisify } from "util";
42
107
 
43
108
  // src/updates/linux-process-state.ts
44
109
  function linuxProcessIsExited(stat, pid) {
@@ -56,7 +121,12 @@ function linuxProcessIsExited(stat, pid) {
56
121
  }
57
122
 
58
123
  // src/updates/update-process-fence.ts
59
- var execute = promisify(execFile);
124
+ class UpdateProcessFenceCancelledError extends Error {
125
+ constructor() {
126
+ super("Update helper cancellation was requested");
127
+ this.name = "UpdateProcessFenceCancelledError";
128
+ }
129
+ }
60
130
  function isProcessRunning(pid) {
61
131
  try {
62
132
  process.kill(pid, 0);
@@ -83,60 +153,77 @@ async function hasVerifiedProcessExited(pid) {
83
153
  }
84
154
  return linuxProcessIsExited(stat, pid);
85
155
  }
86
- async function waitForUpdateProcesses(options) {
87
- if (!Array.isArray(options.processes) || options.processes.length < 1 || options.processes.length > 16 || !Number.isSafeInteger(options.timeoutMs) || options.timeoutMs < 1 || options.timeoutMs > 120000)
88
- throw new Error("Invalid update process fence");
89
- const seen = new Set, env = {};
90
- const deadline = Date.now() + options.timeoutMs;
91
- for (const key of ["PATH", "SystemRoot", "WINDIR", "TMP", "TEMP", "TMPDIR", "LANG", "LC_ALL"])
92
- if ((options.env ?? process.env)[key])
93
- env[key] = (options.env ?? process.env)[key];
94
- async function executable(pid) {
95
- if (process.platform === "linux")
96
- return realpath(`/proc/${pid}/exe`);
97
- if (process.platform === "darwin")
98
- return realpath((await execute("/bin/ps", ["-p", String(pid), "-o", "comm="], {
99
- env,
100
- timeout: Math.max(1, Math.min(5000, deadline - Date.now())),
101
- maxBuffer: 16384
102
- })).stdout.trim());
103
- if (process.platform === "win32") {
104
- const library = dlopen("kernel32.dll", {
105
- OpenProcess: { args: [FFIType.u32, FFIType.i32, FFIType.u32], returns: FFIType.ptr },
106
- QueryFullProcessImageNameW: {
107
- args: [FFIType.ptr, FFIType.u32, FFIType.ptr, FFIType.ptr],
108
- returns: FFIType.i32
109
- },
110
- CloseHandle: { args: [FFIType.ptr], returns: FFIType.i32 }
111
- });
156
+ async function executable(pid) {
157
+ if (process.platform === "linux")
158
+ return realpath(`/proc/${pid}/exe`);
159
+ if (process.platform === "darwin") {
160
+ const library = dlopen("/usr/lib/libproc.dylib", {
161
+ proc_pidpath: { args: [FFIType.i32, FFIType.ptr, FFIType.u32], returns: FFIType.i32 }
162
+ });
163
+ try {
164
+ const buffer = Buffer.alloc(4096);
165
+ const count = library.symbols.proc_pidpath(pid, ptr(buffer), buffer.length);
166
+ if (count <= 0 || count >= buffer.length)
167
+ throw new Error("Cannot inspect update process");
168
+ const end = buffer.indexOf(0);
169
+ if (end <= 0 || end > count)
170
+ throw new Error("Invalid update process path");
171
+ const path = buffer.subarray(0, end).toString("utf8");
172
+ if (!isAbsolute2(path))
173
+ throw new Error("Invalid update process path");
174
+ return await realpath(path);
175
+ } finally {
176
+ library.close();
177
+ }
178
+ }
179
+ if (process.platform === "win32") {
180
+ const library = dlopen("kernel32.dll", {
181
+ OpenProcess: { args: [FFIType.u32, FFIType.i32, FFIType.u32], returns: FFIType.ptr },
182
+ QueryFullProcessImageNameW: {
183
+ args: [FFIType.ptr, FFIType.u32, FFIType.ptr, FFIType.ptr],
184
+ returns: FFIType.i32
185
+ },
186
+ CloseHandle: { args: [FFIType.ptr], returns: FFIType.i32 }
187
+ });
188
+ try {
189
+ const handle = library.symbols.OpenProcess(4096, 0, pid);
190
+ if (!handle)
191
+ throw new Error("Cannot open update process");
112
192
  try {
113
- const handle = library.symbols.OpenProcess(4096, 0, pid);
114
- if (!handle)
115
- throw new Error("Cannot open update process");
116
- try {
117
- const buffer = Buffer.alloc(32768 * 2), length = Buffer.alloc(4);
118
- length.writeUInt32LE(32768);
119
- if (!library.symbols.QueryFullProcessImageNameW(handle, 0, ptr(buffer), ptr(length)))
120
- throw new Error("Cannot inspect update process");
121
- const count = length.readUInt32LE();
122
- if (!count || count >= 32768)
123
- throw new Error("Invalid update process path");
124
- return await realpath(buffer.subarray(0, count * 2).toString("utf16le"));
125
- } finally {
126
- library.symbols.CloseHandle(handle);
127
- }
193
+ const buffer = Buffer.alloc(32768 * 2), length = Buffer.alloc(4);
194
+ length.writeUInt32LE(32768);
195
+ if (!library.symbols.QueryFullProcessImageNameW(handle, 0, ptr(buffer), ptr(length)))
196
+ throw new Error("Cannot inspect update process");
197
+ const count = length.readUInt32LE();
198
+ if (!count || count >= 32768)
199
+ throw new Error("Invalid update process path");
200
+ return await realpath(buffer.subarray(0, count * 2).toString("utf16le"));
128
201
  } finally {
129
- library.close();
202
+ library.symbols.CloseHandle(handle);
130
203
  }
204
+ } finally {
205
+ library.close();
131
206
  }
132
- throw new Error("Unsupported update process platform");
133
207
  }
208
+ throw new Error("Unsupported update process platform");
209
+ }
210
+ async function waitForUpdateProcesses(options) {
211
+ if (!Array.isArray(options.processes) || options.processes.length < 1 || options.processes.length > 16 || !Number.isSafeInteger(options.timeoutMs) || options.timeoutMs < 1 || options.timeoutMs > 120000)
212
+ throw new Error("Invalid update process fence");
213
+ const seen = new Set;
214
+ const deadline = performance.now() + options.timeoutMs;
134
215
  const waiting = new Set;
216
+ const throwIfCancelled = async () => {
217
+ if (await options.cancellationRequested?.())
218
+ throw new UpdateProcessFenceCancelledError;
219
+ };
220
+ await throwIfCancelled();
135
221
  for (const processInfo of options.processes) {
136
222
  if (!processInfo || !Number.isSafeInteger(processInfo.pid) || processInfo.pid < 2 || processInfo.pid > 4294967295 || processInfo.pid === process.pid || seen.has(processInfo.pid) || typeof processInfo.executable !== "string" || !isAbsolute2(processInfo.executable))
137
223
  throw new Error("Invalid update process identity");
138
- if (Date.now() >= deadline)
224
+ if (performance.now() >= deadline)
139
225
  throw new Error("Update process fence timed out");
226
+ await throwIfCancelled();
140
227
  seen.add(processInfo.pid);
141
228
  if (!isProcessRunning(processInfo.pid))
142
229
  throw new Error("Update process exited before verification");
@@ -151,44 +238,51 @@ async function waitForUpdateProcesses(options) {
151
238
  throw new Error("Update process executable mismatch");
152
239
  waiting.add(processInfo.pid);
153
240
  }
154
- if (Date.now() >= deadline)
241
+ if (performance.now() >= deadline)
155
242
  throw new Error("Update process fence timed out");
156
243
  for (const pid of waiting)
157
244
  if (!isProcessRunning(pid))
158
245
  throw new Error("Update process exited before verification");
246
+ await throwIfCancelled();
159
247
  const notified = options.onVerified?.();
160
248
  if (typeof notified === "object" && notified !== null && "then" in notified)
161
249
  throw new Error("Update process acknowledgement must be synchronous");
162
250
  while (waiting.size) {
251
+ await throwIfCancelled();
163
252
  for (const pid of waiting)
164
253
  if (await hasVerifiedProcessExited(pid))
165
254
  waiting.delete(pid);
166
255
  if (!waiting.size)
167
256
  return;
168
- if (Date.now() >= deadline)
257
+ if (performance.now() >= deadline)
169
258
  throw new Error("Update processes did not exit");
170
- await Bun.sleep(Math.min(100, Math.max(1, deadline - Date.now())));
259
+ await Bun.sleep(Math.min(100, Math.max(1, deadline - performance.now())));
171
260
  }
172
261
  }
173
262
 
174
263
  // src/updates/update-swap.ts
175
- import { rm } from "fs/promises";
176
- import { basename, dirname as dirname2, isAbsolute as isAbsolute4, join as join2, resolve as resolve3 } from "path";
264
+ import { createHash } from "crypto";
265
+ import { constants as constants4 } from "fs";
266
+ import { lstat as lstat2, open as open4, readdir, readFile as readFile4, readlink } from "fs/promises";
267
+ import { basename as basename2, dirname as dirname3, isAbsolute as isAbsolute5, join as join6, resolve as resolve4 } from "path";
177
268
 
178
- // src/native/exclusive-rename.ts
269
+ // src/native/directory-exchange.ts
270
+ import { randomUUID as randomUUID2 } from "crypto";
271
+ import { mkdir, readFile as readFile2, rm, writeFile as writeFile2 } from "fs/promises";
179
272
  import { dlopen as dlopen2, FFIType as FFIType2, ptr as ptr2 } from "bun:ffi";
180
- import { isAbsolute as isAbsolute3, resolve as resolve2 } from "path";
181
- function renameExclusive(source, destination) {
273
+ import { isAbsolute as isAbsolute3, join as join3, resolve as resolve2 } from "path";
274
+ var RENAME_EXCHANGE = 2;
275
+ function exchangeDirectories(source, destination) {
182
276
  if (typeof source !== "string" || typeof destination !== "string" || !isAbsolute3(source) || !isAbsolute3(destination) || resolve2(source) !== source || resolve2(destination) !== destination || source === destination || source.includes("\x00") || destination.includes("\x00"))
183
- throw new Error("Invalid exclusive rename paths");
277
+ throw new Error("Invalid atomic directory exchange paths");
184
278
  if (process.platform === "darwin") {
185
279
  const library = dlopen2("libSystem.B.dylib", {
186
280
  renamex_np: { args: [FFIType2.ptr, FFIType2.ptr, FFIType2.u32], returns: FFIType2.i32 }
187
281
  });
188
282
  try {
189
283
  const from = Buffer.from(source + "\x00"), to = Buffer.from(destination + "\x00");
190
- if (library.symbols.renamex_np(ptr2(from), ptr2(to), 4) !== 0)
191
- throw new Error("Exclusive rename failed");
284
+ if (library.symbols.renamex_np(ptr2(from), ptr2(to), RENAME_EXCHANGE) !== 0)
285
+ throw new Error("Atomic directory exchange is unsupported or failed");
192
286
  } finally {
193
287
  library.close();
194
288
  }
@@ -201,96 +295,1380 @@ function renameExclusive(source, destination) {
201
295
  });
202
296
  try {
203
297
  const from = Buffer.from(source + "\x00"), to = Buffer.from(destination + "\x00");
204
- if (library.symbols.renameat2(-100, ptr2(from), -100, ptr2(to), 1) !== 0)
205
- throw new Error("Exclusive rename failed");
298
+ if (library.symbols.renameat2(-100, ptr2(from), -100, ptr2(to), RENAME_EXCHANGE) !== 0)
299
+ throw new Error("Atomic directory exchange is unsupported or failed");
206
300
  } finally {
207
301
  library.close();
208
302
  }
209
- } else if (process.platform === "win32") {
210
- const library = dlopen2("kernel32.dll", {
211
- MoveFileW: { args: [FFIType2.ptr, FFIType2.ptr], returns: FFIType2.i32 }
212
- });
303
+ } else {
304
+ throw new Error("Atomic directory exchange is unsupported on this platform");
305
+ }
306
+ }
307
+ async function probeDirectoryExchange(parent, exchange = exchangeDirectories) {
308
+ if (typeof parent !== "string" || !isAbsolute3(parent) || resolve2(parent) !== parent || parent.includes("\x00"))
309
+ throw new Error("Invalid directory exchange probe parent");
310
+ const id = randomUUID2();
311
+ const first = join3(parent, `.framework-exchange-probe-${id}-a`);
312
+ const second = join3(parent, `.framework-exchange-probe-${id}-b`);
313
+ const marker = "exchange-probe";
314
+ const firstValue = `${id}:first`;
315
+ const secondValue = `${id}:second`;
316
+ let firstCreated = false;
317
+ let secondCreated = false;
318
+ try {
319
+ await mkdir(first, { mode: 448 });
320
+ firstCreated = true;
321
+ await mkdir(second, { mode: 448 });
322
+ secondCreated = true;
323
+ await writeFile2(join3(first, marker), firstValue, { flag: "wx", mode: 384 });
324
+ await writeFile2(join3(second, marker), secondValue, { flag: "wx", mode: 384 });
325
+ exchange(first, second);
326
+ const [firstAfter, secondAfter] = await Promise.all([
327
+ readFile2(join3(first, marker), "utf8"),
328
+ readFile2(join3(second, marker), "utf8")
329
+ ]);
330
+ if (firstAfter !== secondValue || secondAfter !== firstValue)
331
+ throw new Error("Directory exchange did not exchange both probe trees");
332
+ } finally {
333
+ const cleanup = [];
334
+ if (firstCreated)
335
+ cleanup.push(rm(first, { recursive: true, force: true }));
336
+ if (secondCreated)
337
+ cleanup.push(rm(second, { recursive: true, force: true }));
338
+ await Promise.all(cleanup);
339
+ }
340
+ }
341
+
342
+ // src/updates/update-state-store.ts
343
+ import { randomUUID as randomUUID3 } from "crypto";
344
+ import { constants as constants3 } from "fs";
345
+ import { lstat, open as open3, readFile as readFile3, rename, unlink as unlink2, writeFile as writeFile3 } from "fs/promises";
346
+ import { join as join5 } from "path";
347
+
348
+ // src/updates/update-lock.ts
349
+ import { basename, dirname as dirname2, isAbsolute as isAbsolute4, resolve as resolve3, join as join4 } from "path";
350
+
351
+ // src/updates/native-file-lock.ts
352
+ import { constants as constants2 } from "fs";
353
+ import { open as open2 } from "fs/promises";
354
+ import { dlopen as dlopen3, FFIType as FFIType3, ptr as ptr3, read } from "bun:ffi";
355
+ var LOCK_SH = 1;
356
+ var LOCK_EX = 2;
357
+ var LOCK_NB = 4;
358
+ var LOCK_UN = 8;
359
+ var LOCKFILE_EXCLUSIVE_LOCK = 2;
360
+ var LOCKFILE_FAIL_IMMEDIATELY = 1;
361
+ var INVALID_HANDLE_VALUE = 0xffffffffffffffffn;
362
+ var ERROR_LOCK_VIOLATION = 33;
363
+ async function tryAcquireNativeFileLock(path, mode) {
364
+ if (mode !== "shared" && mode !== "exclusive")
365
+ throw new Error("Invalid native file lock mode");
366
+ if (process.platform === "win32")
367
+ return tryAcquireWindows(path, mode);
368
+ if (process.platform !== "darwin" && process.platform !== "linux")
369
+ throw new Error("Unsupported native file lock platform");
370
+ const noFollow = constants2.O_NOFOLLOW;
371
+ if (noFollow === undefined)
372
+ throw new Error("Safe native lock file opening is unavailable");
373
+ const file = await open2(path, constants2.O_CREAT | constants2.O_RDWR | noFollow, 384);
374
+ let library;
375
+ let acquired = false;
376
+ try {
377
+ const info = await file.stat();
378
+ if (!info.isFile())
379
+ throw new Error("Invalid native lock file");
380
+ const darwin = process.platform === "darwin";
381
+ library = loadPosixLibrary(darwin);
382
+ const result = library.symbols.flock(file.fd, (mode === "shared" ? LOCK_SH : LOCK_EX) | LOCK_NB);
383
+ if (result !== 0) {
384
+ const errnoSymbol = darwin ? "__error" : "__errno_location";
385
+ const errno = read.i32(library.symbols[errnoSymbol](), 0);
386
+ if (errno === (darwin ? 35 : 11))
387
+ return;
388
+ throw new Error("Could not acquire native file lock (errno " + errno + ")");
389
+ }
390
+ acquired = true;
391
+ return {
392
+ async release() {
393
+ if (!acquired)
394
+ return;
395
+ acquired = false;
396
+ let failure;
397
+ try {
398
+ if (library.symbols.flock(file.fd, LOCK_UN) !== 0) {
399
+ const errnoSymbol = darwin ? "__error" : "__errno_location";
400
+ const errno = read.i32(library.symbols[errnoSymbol](), 0);
401
+ failure = new Error("Could not release native file lock (errno " + errno + ")");
402
+ }
403
+ } finally {
404
+ const heldLibrary = library;
405
+ library = undefined;
406
+ try {
407
+ heldLibrary.close();
408
+ } finally {
409
+ await file.close();
410
+ }
411
+ }
412
+ if (failure)
413
+ throw failure;
414
+ }
415
+ };
416
+ } finally {
417
+ if (!acquired) {
418
+ const openedLibrary = library;
419
+ library = undefined;
420
+ try {
421
+ openedLibrary?.close();
422
+ } finally {
423
+ await file.close();
424
+ }
425
+ }
426
+ }
427
+ }
428
+ function loadPosixLibrary(darwin) {
429
+ const errnoSymbol = darwin ? "__error" : "__errno_location";
430
+ const candidates = darwin ? ["libSystem.B.dylib"] : ["libc.so.6", "libc.so"];
431
+ let failure;
432
+ for (const name of candidates) {
213
433
  try {
214
- const from = Buffer.from(source + "\x00", "utf16le"), to = Buffer.from(destination + "\x00", "utf16le");
215
- if (library.symbols.MoveFileW(ptr2(from), ptr2(to)) === 0)
216
- throw new Error("Exclusive rename failed");
217
- } finally {
218
- library.close();
434
+ return dlopen3(name, {
435
+ flock: { args: [FFIType3.i32, FFIType3.i32], returns: FFIType3.i32 },
436
+ [errnoSymbol]: { args: [], returns: FFIType3.ptr }
437
+ });
438
+ } catch (error) {
439
+ failure = error;
219
440
  }
220
- } else
221
- throw new Error("Unsupported exclusive rename platform");
441
+ }
442
+ throw new Error("Could not load native file locking support", { cause: failure });
443
+ }
444
+ async function tryAcquireWindows(path, mode) {
445
+ if (process.arch !== "x64" && process.arch !== "arm64")
446
+ throw new Error("Unsupported Windows native file lock architecture");
447
+ const library = dlopen3("kernel32.dll", {
448
+ CreateFileW: {
449
+ args: [
450
+ FFIType3.ptr,
451
+ FFIType3.u32,
452
+ FFIType3.u32,
453
+ FFIType3.ptr,
454
+ FFIType3.u32,
455
+ FFIType3.u32,
456
+ FFIType3.u64
457
+ ],
458
+ returns: FFIType3.u64
459
+ },
460
+ LockFileEx: {
461
+ args: [FFIType3.u64, FFIType3.u32, FFIType3.u32, FFIType3.u32, FFIType3.u32, FFIType3.ptr],
462
+ returns: FFIType3.i32
463
+ },
464
+ UnlockFileEx: {
465
+ args: [FFIType3.u64, FFIType3.u32, FFIType3.u32, FFIType3.u32, FFIType3.ptr],
466
+ returns: FFIType3.i32
467
+ },
468
+ CloseHandle: { args: [FFIType3.u64], returns: FFIType3.i32 },
469
+ GetLastError: { args: [], returns: FFIType3.u32 }
470
+ });
471
+ const name = Buffer.from(path + "\x00", "utf16le");
472
+ const handle = library.symbols.CreateFileW(ptr3(name), 3221225472, 3, 0, 4, 128, 0);
473
+ if (handle === 0n || handle === INVALID_HANDLE_VALUE) {
474
+ const error = library.symbols.GetLastError();
475
+ library.close();
476
+ throw new Error("Could not open native lock file (Windows error " + error + ")");
477
+ }
478
+ const overlapped = Buffer.alloc(32);
479
+ const flags = LOCKFILE_FAIL_IMMEDIATELY | (mode === "exclusive" ? LOCKFILE_EXCLUSIVE_LOCK : 0);
480
+ if (!library.symbols.LockFileEx(handle, flags, 0, 1, 0, ptr3(overlapped))) {
481
+ const error = library.symbols.GetLastError();
482
+ library.symbols.CloseHandle(handle);
483
+ library.close();
484
+ if (error === ERROR_LOCK_VIOLATION)
485
+ return;
486
+ throw new Error("Could not acquire native file lock (Windows error " + error + ")");
487
+ }
488
+ let acquired = true;
489
+ return {
490
+ async release() {
491
+ if (!acquired)
492
+ return;
493
+ acquired = false;
494
+ let failure;
495
+ try {
496
+ if (!library.symbols.UnlockFileEx(handle, 0, 1, 0, ptr3(overlapped))) {
497
+ const error = library.symbols.GetLastError();
498
+ failure = new Error("Could not release native file lock (Windows error " + error + ")");
499
+ }
500
+ } finally {
501
+ try {
502
+ library.symbols.CloseHandle(handle);
503
+ } finally {
504
+ library.close();
505
+ }
506
+ }
507
+ if (failure)
508
+ throw failure;
509
+ }
510
+ };
222
511
  }
223
512
 
224
- // src/updates/update-exclusive-rename.ts
225
- var renameUpdateExclusive = renameExclusive;
513
+ // src/updates/update-lock.ts
514
+ function updateLockPath(target) {
515
+ if (typeof target !== "string" || !isAbsolute4(target) || resolve3(target) !== target || target.includes("\x00"))
516
+ throw new Error("Invalid update lock target");
517
+ return join4(dirname2(target), `.${basename(target)}.framework-update.lock`);
518
+ }
519
+ async function tryAcquireUpdateLock(target) {
520
+ return tryAcquireNativeFileLock(updateLockPath(target), "exclusive");
521
+ }
522
+
523
+ // src/updates/update-state-store.ts
524
+ class UpdateLockBusyError extends Error {
525
+ constructor() {
526
+ super("Another app instance is changing the staged update");
527
+ this.name = "UpdateLockBusyError";
528
+ }
529
+ }
530
+ async function acquireUpdateLock(target, timeoutMs = 5000) {
531
+ const deadline = Date.now() + timeoutMs;
532
+ while (true) {
533
+ const lock = await tryAcquireUpdateLock(target);
534
+ if (lock)
535
+ return lock;
536
+ if (Date.now() >= deadline)
537
+ throw new UpdateLockBusyError;
538
+ await Bun.sleep(Math.min(25, Math.max(1, deadline - Date.now())));
539
+ }
540
+ }
541
+ function parseState(value) {
542
+ if (typeof value !== "object" || value === null || Array.isArray(value))
543
+ throw new Error("Invalid update staging state");
544
+ const record = value;
545
+ const candidateTreeIdentity = record.candidateTreeIdentity;
546
+ const candidateTreeDigest = record.candidateTreeDigest;
547
+ const previousTreeIdentity = record.previousTreeIdentity;
548
+ if (record.schema !== 1 || typeof record.generation !== "string" || !/^[0-9a-f]{8}-[0-9a-f-]{27}$/i.test(record.generation) || !["staged", "armed", "swapping", "completed", "retiring", "retired", "failed"].includes(String(record.phase)) || typeof record.version !== "string" || !/^\d+\.\d+\.\d+(?:-dev\.\d+)?$/.test(record.version) || typeof record.previousVersion !== "string" || !/^\d+\.\d+\.\d+(?:-dev\.\d+)?$/.test(record.previousVersion) || candidateTreeDigest !== undefined && (typeof candidateTreeDigest !== "string" || !/^[0-9a-f]{64}$/.test(candidateTreeDigest)) || candidateTreeIdentity !== undefined && (typeof candidateTreeIdentity !== "object" || candidateTreeIdentity === null || Array.isArray(candidateTreeIdentity) || Object.keys(candidateTreeIdentity).length !== 2 || typeof candidateTreeIdentity.device !== "string" || !/^[1-9]\d{0,19}$/.test(candidateTreeIdentity.device) || typeof candidateTreeIdentity.inode !== "string" || !/^[1-9]\d{0,19}$/.test(candidateTreeIdentity.inode)) || previousTreeIdentity !== undefined && (typeof previousTreeIdentity !== "object" || previousTreeIdentity === null || Array.isArray(previousTreeIdentity) || Object.keys(previousTreeIdentity).length !== 2 || typeof previousTreeIdentity.device !== "string" || !/^[1-9]\d{0,19}$/.test(previousTreeIdentity.device) || typeof previousTreeIdentity.inode !== "string" || !/^[1-9]\d{0,19}$/.test(previousTreeIdentity.inode)) || record.signedRelease !== undefined && (typeof record.signedRelease !== "object" || record.signedRelease === null || Array.isArray(record.signedRelease) || Object.keys(record.signedRelease).length !== 2 || !Object.hasOwn(record.signedRelease, "descriptor") || typeof record.signedRelease.signature !== "string") || record.helperPid !== undefined && (!Number.isSafeInteger(record.helperPid) || record.helperPid < 2) || record.helperOwner !== undefined && (typeof record.helperOwner !== "string" || !/^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(record.helperOwner)) || record.launchGateOwner !== undefined && (typeof record.launchGateOwner !== "string" || !/^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(record.launchGateOwner)) || Object.keys(record).some((key) => ![
549
+ "schema",
550
+ "generation",
551
+ "phase",
552
+ "version",
553
+ "previousVersion",
554
+ "candidateTreeIdentity",
555
+ "candidateTreeDigest",
556
+ "previousTreeIdentity",
557
+ "signedRelease",
558
+ "helperPid",
559
+ "helperOwner",
560
+ "launchGateOwner"
561
+ ].includes(key)))
562
+ throw new Error("Invalid update staging state");
563
+ if ((record.phase === "armed" || record.phase === "swapping" || record.phase === "completed" || record.phase === "retiring" || record.phase === "retired") && candidateTreeIdentity === undefined)
564
+ throw new Error("Invalid update staging state");
565
+ if ((record.phase === "retiring" || record.phase === "retired") && previousTreeIdentity === undefined)
566
+ throw new Error("Invalid update staging state");
567
+ return Object.freeze(record);
568
+ }
569
+ async function readUpdateStageState(staging) {
570
+ const path = join5(staging, "state.json");
571
+ let info;
572
+ try {
573
+ info = await lstat(path);
574
+ } catch (error) {
575
+ if (error.code === "ENOENT")
576
+ return;
577
+ throw error;
578
+ }
579
+ if (!info.isFile() || info.isSymbolicLink() || info.size < 1 || info.size > 4096)
580
+ throw new Error("Invalid update staging state");
581
+ return parseState(JSON.parse(await readFile3(path, "utf8")));
582
+ }
583
+ async function syncUpdateStageDirectory(staging) {
584
+ const directory = await open3(staging, constants3.O_RDONLY);
585
+ try {
586
+ await directory.sync();
587
+ } finally {
588
+ await directory.close();
589
+ }
590
+ }
591
+ async function writeUpdateStageState(staging, state) {
592
+ if (typeof state.generation !== "string" || !/^[0-9a-f]{8}-[0-9a-f-]{27}$/i.test(state.generation))
593
+ throw new Error("Invalid update staging state");
594
+ const path = join5(staging, "state.json");
595
+ const temporary = join5(staging, `.state-${state.generation}-${randomUUID3()}.tmp`);
596
+ await writeFile3(temporary, JSON.stringify(state) + `
597
+ `, { flag: "wx", mode: 384 });
598
+ try {
599
+ await rename(temporary, path);
600
+ } catch (error) {
601
+ await unlink2(temporary).catch(() => {});
602
+ throw error;
603
+ }
604
+ }
605
+ async function writeUpdateStageStateDurably(staging, state) {
606
+ if (typeof state.generation !== "string" || !/^[0-9a-f]{8}-[0-9a-f-]{27}$/i.test(state.generation))
607
+ throw new Error("Invalid update staging state");
608
+ const path = join5(staging, "state.json");
609
+ const temporary = join5(staging, `.state-${state.generation}-${randomUUID3()}.tmp`);
610
+ let renamed = false;
611
+ try {
612
+ const file = await open3(temporary, constants3.O_WRONLY | constants3.O_CREAT | constants3.O_EXCL, 384);
613
+ try {
614
+ await file.writeFile(JSON.stringify(state) + `
615
+ `);
616
+ await file.sync();
617
+ } finally {
618
+ await file.close();
619
+ }
620
+ await rename(temporary, path);
621
+ renamed = true;
622
+ await syncUpdateStageDirectory(staging);
623
+ } catch (error) {
624
+ if (!renamed)
625
+ await unlink2(temporary).catch(() => {});
626
+ throw error;
627
+ }
628
+ }
226
629
 
227
630
  // src/updates/update-swap.ts
228
631
  function updateStagingFor(target) {
229
- if (typeof target !== "string" || !isAbsolute4(target) || resolve3(target) !== target)
632
+ if (typeof target !== "string" || !isAbsolute5(target) || resolve4(target) !== target)
230
633
  throw new Error("Invalid update target");
231
- return join2(dirname2(target), `.${basename(target)}.framework-update`);
634
+ return join6(dirname3(target), `.${basename2(target)}.framework-update`);
635
+ }
636
+ async function readUpdateTreeVersion(tree) {
637
+ const versionPath = join6(tree, ...process.platform === "darwin" ? ["Contents", "Resources"] : ["Resources"], "version.json");
638
+ try {
639
+ const value = JSON.parse(await readFile4(versionPath, "utf8"));
640
+ if (typeof value !== "object" || value === null || typeof value.version !== "string")
641
+ return;
642
+ return value.version;
643
+ } catch {
644
+ return;
645
+ }
646
+ }
647
+ function updateTreeIdentityFromStat(info) {
648
+ if (!info.isDirectory() || info.isSymbolicLink() || info.dev <= 0n || info.ino <= 0n)
649
+ return;
650
+ return { device: info.dev.toString(10), inode: info.ino.toString(10) };
232
651
  }
233
- async function swapUpdateTree(options) {
652
+ async function readUpdateTreeIdentity(tree) {
653
+ const info = await lstat2(tree, { bigint: true });
654
+ return updateTreeIdentityFromStat(info);
655
+ }
656
+ function sameUpdateTreeIdentity(left, right) {
657
+ return left !== undefined && right !== undefined && left.device === right.device && left.inode === right.inode;
658
+ }
659
+ function sameTreeEntrySnapshot(left, right) {
660
+ return left.dev === right.dev && left.ino === right.ino && left.mode === right.mode && left.nlink === right.nlink && left.size === right.size && left.mtimeNs === right.mtimeNs && left.ctimeNs === right.ctimeNs;
661
+ }
662
+ async function readUpdateTreeDigest(tree) {
663
+ const hash = createHash("sha256");
664
+ hash.update("adea-framework-update-tree\x00v1\x00", "utf8");
665
+ const root = await lstat2(tree, { bigint: true });
666
+ if (!root.isDirectory() || root.isSymbolicLink())
667
+ throw new Error("Update tree is not a real directory");
668
+ const rootDevice = root.dev;
669
+ let entryCount = 0n;
670
+ const writeRecord = (kind, relative, mode, size, linkTarget) => {
671
+ const name = Buffer.from(relative, "utf8");
672
+ if (name.length > 4294967295)
673
+ throw new Error("Update tree path is too long");
674
+ const tag = kind === "directory" ? 68 : kind === "file" ? 70 : 76;
675
+ const header = Buffer.allocUnsafe(1 + 4 + name.length + 4 + 8);
676
+ header.writeUInt8(tag, 0);
677
+ header.writeUInt32BE(name.length, 1);
678
+ name.copy(header, 5);
679
+ header.writeUInt32BE(Number(mode & 0o7777n), 5 + name.length);
680
+ header.writeBigUInt64BE(size, 9 + name.length);
681
+ hash.update(header);
682
+ if (linkTarget) {
683
+ hash.update(linkTarget);
684
+ hash.update(Buffer.from([0]));
685
+ }
686
+ entryCount++;
687
+ };
688
+ const visit = async (path, relative) => {
689
+ const before = await lstat2(path, { bigint: true });
690
+ if (relative === "" && !sameTreeEntrySnapshot(root, before))
691
+ throw new Error("Update tree root changed before its digest was computed");
692
+ if (before.dev !== rootDevice)
693
+ throw new Error("Update tree crosses a filesystem device");
694
+ if (before.isSymbolicLink()) {
695
+ const target = Buffer.from(await readlink(path), "utf8");
696
+ const after = await lstat2(path, { bigint: true });
697
+ if (!sameTreeEntrySnapshot(before, after))
698
+ throw new Error("Update tree changed while reading a symbolic link");
699
+ writeRecord("symlink", relative, before.mode, BigInt(target.length), target);
700
+ return;
701
+ }
702
+ if (before.isDirectory()) {
703
+ writeRecord("directory", relative, before.mode, 0n);
704
+ const names = (await readdir(path)).toSorted((left, right) => Buffer.compare(Buffer.from(left, "utf8"), Buffer.from(right, "utf8")));
705
+ for (const name of names) {
706
+ const child = relative ? `${relative}/${name}` : name;
707
+ await visit(join6(path, name), child);
708
+ }
709
+ const after = await lstat2(path, { bigint: true });
710
+ if (!sameTreeEntrySnapshot(before, after))
711
+ throw new Error("Update tree changed while reading a directory");
712
+ return;
713
+ }
714
+ if (!before.isFile() || before.nlink !== 1n || before.size < 0n)
715
+ throw new Error("Update tree contains an unsupported filesystem entry");
716
+ writeRecord("file", relative, before.mode, before.size);
717
+ const noFollow = constants4.O_NOFOLLOW ?? 0;
718
+ const file = await open4(path, constants4.O_RDONLY | noFollow | (constants4.O_NONBLOCK ?? 0));
719
+ try {
720
+ const opened = await file.stat({ bigint: true });
721
+ if (!opened.isFile() || !sameTreeEntrySnapshot(before, opened))
722
+ throw new Error("Update tree changed before a file could be read");
723
+ let bytesRead = 0n;
724
+ const buffer = Buffer.allocUnsafe(128 * 1024);
725
+ for (;; ) {
726
+ const result = await file.read(buffer, 0, buffer.length, null);
727
+ if (result.bytesRead === 0)
728
+ break;
729
+ bytesRead += BigInt(result.bytesRead);
730
+ hash.update(buffer.subarray(0, result.bytesRead));
731
+ }
732
+ const afterOpen = await file.stat({ bigint: true });
733
+ const afterPath = await lstat2(path, { bigint: true });
734
+ if (bytesRead !== before.size || !sameTreeEntrySnapshot(opened, afterOpen) || !sameTreeEntrySnapshot(before, afterPath))
735
+ throw new Error("Update tree changed while reading a file");
736
+ } finally {
737
+ await file.close();
738
+ }
739
+ };
740
+ await visit(tree, "");
741
+ const finalRoot = await lstat2(tree, { bigint: true });
742
+ if (!sameTreeEntrySnapshot(root, finalRoot))
743
+ throw new Error("Update tree changed while its digest was computed");
744
+ const count = Buffer.allocUnsafe(8);
745
+ count.writeBigUInt64BE(entryCount);
746
+ hash.update(count);
747
+ return hash.digest("hex");
748
+ }
749
+ function sameUpdateTreeDigest(left, right) {
750
+ return typeof left === "string" && typeof right === "string" && /^[0-9a-f]{64}$/.test(left) && left === right;
751
+ }
752
+ async function syncDirectoryPath(path) {
753
+ const directory = await open4(path, constants4.O_RDONLY);
754
+ try {
755
+ await directory.sync();
756
+ } finally {
757
+ await directory.close();
758
+ }
759
+ }
760
+ async function syncUpdateTree(tree) {
761
+ const root = await lstat2(tree);
762
+ if (!root.isDirectory())
763
+ throw new Error("Update tree changed while syncing");
764
+ const rootDevice = root.dev;
765
+ const syncEntry = async (path) => {
766
+ const info = await lstat2(path);
767
+ if (info.isSymbolicLink())
768
+ return;
769
+ if (info.dev !== rootDevice)
770
+ throw new Error("Update tree crosses a filesystem device");
771
+ if (info.isDirectory()) {
772
+ for (const name of await readdir(path))
773
+ await syncEntry(join6(path, name));
774
+ await syncDirectoryPath(path);
775
+ return;
776
+ }
777
+ if (!info.isFile())
778
+ throw new Error("Update tree contains an unsupported filesystem entry");
779
+ const file = await open4(path, constants4.O_RDONLY | (constants4.O_NOFOLLOW ?? 0));
780
+ try {
781
+ const opened = await file.stat();
782
+ if (!opened.isFile())
783
+ throw new Error("Update tree changed while syncing");
784
+ await file.sync();
785
+ } finally {
786
+ await file.close();
787
+ }
788
+ };
789
+ await syncEntry(tree);
790
+ const final = await lstat2(tree);
791
+ if (!final.isDirectory() || final.dev !== rootDevice)
792
+ throw new Error("Update tree changed while syncing");
793
+ }
794
+ async function syncUpdateTreeParent(target) {
795
+ const directory = await open4(dirname3(target), constants4.O_RDONLY);
796
+ try {
797
+ await directory.sync();
798
+ } finally {
799
+ await directory.close();
800
+ }
801
+ }
802
+ async function exists(path) {
803
+ return lstat2(path).then(() => true, (error) => {
804
+ if (error.code === "ENOENT")
805
+ return false;
806
+ throw error;
807
+ });
808
+ }
809
+ async function assertDirectory(path) {
810
+ const info = await lstat2(path);
811
+ if (!info.isDirectory() || info.isSymbolicLink())
812
+ throw new Error("Update exchange requires real directories");
813
+ }
814
+ async function swapUpdateTreeWhileLocked(options, exchangeOperation = exchangeDirectories) {
234
815
  const { target, staging } = options;
235
- if (dirname2(staging) !== dirname2(target) || staging === target)
816
+ if (dirname3(staging) !== dirname3(target) || staging === target)
236
817
  throw new Error("Invalid update swap context");
237
- const old = join2(staging, "old");
238
- renameUpdateExclusive(target, old);
818
+ const candidate = join6(staging, "candidate");
819
+ const legacyOld = join6(staging, "old");
820
+ if (await exists(legacyOld))
821
+ throw new Error("A legacy update tree requires recovery before another swap");
822
+ await assertDirectory(target);
823
+ await assertDirectory(staging);
824
+ await assertDirectory(candidate);
825
+ const [previousVersion, candidateVersion, previousIdentity, candidateIdentity] = await Promise.all([
826
+ readUpdateTreeVersion(target),
827
+ readUpdateTreeVersion(candidate),
828
+ readUpdateTreeIdentity(target),
829
+ readUpdateTreeIdentity(candidate)
830
+ ]);
831
+ if (!previousVersion || !candidateVersion || !previousIdentity || !candidateIdentity || sameUpdateTreeIdentity(previousIdentity, candidateIdentity))
832
+ throw new Error("Update exchange requires identifiable versioned app trees");
833
+ await probeDirectoryExchange(dirname3(target), exchangeOperation);
834
+ exchangeOperation(target, candidate);
835
+ await assertDirectory(target);
836
+ await assertDirectory(candidate);
837
+ const [nextTargetVersion, nextCandidateVersion, nextTargetId, nextCandidateId] = await Promise.all([
838
+ readUpdateTreeVersion(target),
839
+ readUpdateTreeVersion(candidate),
840
+ readUpdateTreeIdentity(target),
841
+ readUpdateTreeIdentity(candidate)
842
+ ]);
843
+ if (nextTargetVersion !== candidateVersion || nextCandidateVersion !== previousVersion || !sameUpdateTreeIdentity(nextTargetId, candidateIdentity) || !sameUpdateTreeIdentity(nextCandidateId, previousIdentity))
844
+ throw new Error("Atomic update exchange did not preserve both app trees");
845
+ }
846
+
847
+ // src/updates/update-launch-gate.ts
848
+ import { randomUUID as randomUUID4 } from "crypto";
849
+ import { constants as constants5 } from "fs";
850
+ import { lstat as lstat3, open as open5, rename as rename2, unlink as unlink3 } from "fs/promises";
851
+ import { basename as basename4, dirname as dirname5, isAbsolute as isAbsolute7, join as join8, resolve as resolve6 } from "path";
852
+
853
+ // src/updates/update-instance-lease.ts
854
+ import { basename as basename3, dirname as dirname4, isAbsolute as isAbsolute6, join as join7, resolve as resolve5 } from "path";
855
+ function updateInstanceLeasePath(target) {
856
+ if (typeof target !== "string" || !isAbsolute6(target) || resolve5(target) !== target || target.includes("\x00"))
857
+ throw new Error("Invalid update instance lease target");
858
+ return join7(dirname4(target), "." + basename3(target) + ".framework-instance-lease.lock");
859
+ }
860
+ async function tryAcquireUpdateInstanceLease(target, mode) {
861
+ if (mode !== "shared" && mode !== "exclusive")
862
+ throw new Error("Invalid update instance lease mode");
863
+ const lock = await tryAcquireNativeFileLock(updateInstanceLeasePath(target), mode);
864
+ if (!lock)
865
+ return;
866
+ return { mode, release: lock.release };
867
+ }
868
+
869
+ // src/updates/update-launch-gate.ts
870
+ var UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
871
+ var VERSION = /^\d+\.\d+\.\d+(?:-dev\.\d+)?$/;
872
+ var MAX_GATE_BYTES = 1024;
873
+ function validateTarget(target) {
874
+ if (typeof target !== "string" || !isAbsolute7(target) || resolve6(target) !== target || target.includes("\x00"))
875
+ throw new Error("Invalid update launch gate target");
876
+ }
877
+ async function syncDirectory(directoryPath) {
878
+ const directory = await open5(directoryPath, constants5.O_RDONLY);
879
+ try {
880
+ await directory.sync();
881
+ } finally {
882
+ await directory.close();
883
+ }
884
+ }
885
+ function updateLaunchGatePath(target) {
886
+ validateTarget(target);
887
+ return join8(dirname5(target), `.${basename4(target)}.framework-update-launch-gate.json`);
888
+ }
889
+ function updateHelperLivenessPath(target) {
890
+ validateTarget(target);
891
+ return join8(dirname5(target), `.${basename4(target)}.framework-update-helper-liveness.lock`);
892
+ }
893
+ var helperLeaseStates = new WeakMap;
894
+ async function tryAcquireUpdateHelperLiveness(target) {
895
+ validateTarget(target);
896
+ const lock = await tryAcquireNativeFileLock(updateHelperLivenessPath(target), "exclusive");
897
+ if (!lock)
898
+ return;
899
+ const owner = randomUUID4();
900
+ const state = {
901
+ target,
902
+ owner,
903
+ lock,
904
+ state: "available",
905
+ writerGranted: false
906
+ };
907
+ const lease = Object.freeze({
908
+ owner,
909
+ async release() {
910
+ if (state.state === "released")
911
+ return;
912
+ if (state.state !== "available" && state.state !== "cancelled")
913
+ throw new Error("Update helper liveness is owned by an active gate wait or writer");
914
+ state.state = "released";
915
+ helperLeaseStates.delete(lease);
916
+ await lock.release();
917
+ }
918
+ });
919
+ helperLeaseStates.set(lease, state);
920
+ return lease;
921
+ }
922
+ async function cancelUpdateLaunchGateBeforeTransition(target, helperLiveness, expected, validateJournalAndTree) {
923
+ validateTarget(target);
924
+ const gate = validateGateInput(expected);
925
+ if (typeof validateJournalAndTree !== "function")
926
+ throw new Error("Update launch gate cancellation requires journal and tree validation");
927
+ const state = helperLeaseState(helperLiveness, target, gate.owner);
928
+ if (state.writerGranted || state.state === "writer")
929
+ return "writer-active";
930
+ if (state.state !== "available" && state.state !== "waiting")
931
+ throw new Error("Update helper liveness claim is already in use");
932
+ const cancelWait = state.cancelWait;
933
+ const waitSettled = state.waitSettled;
934
+ state.state = "cancelling";
935
+ cancelWait?.();
936
+ try {
937
+ await waitSettled;
938
+ const transition = await acquireUpdateLock(target);
939
+ try {
940
+ const current = await readUpdateLaunchGate(target);
941
+ if (!current)
942
+ return "absent";
943
+ if (!sameGate(current, gate))
944
+ return "owner-mismatch";
945
+ if (await validateJournalAndTree(gate) !== true)
946
+ return "unproven";
947
+ const validated = await readUpdateLaunchGate(target);
948
+ if (!validated)
949
+ return "absent";
950
+ if (!sameGate(validated, gate))
951
+ return "owner-mismatch";
952
+ await unlink3(updateLaunchGatePath(target));
953
+ await syncDirectory(dirname5(updateLaunchGatePath(target)));
954
+ return "cleared";
955
+ } finally {
956
+ await transition.release();
957
+ }
958
+ } finally {
959
+ if (state.state === "cancelling")
960
+ state.state = "cancelled";
961
+ }
962
+ }
963
+ function helperLeaseState(lease, target, owner) {
964
+ const state = helperLeaseStates.get(lease);
965
+ if (!state || state.target !== target || state.owner !== owner || state.state === "released")
966
+ throw new Error("Update helper liveness claim does not match the launch gate");
967
+ return state;
968
+ }
969
+ function validateGateInput(gate) {
970
+ if (typeof gate !== "object" || gate === null || Object.keys(gate).length !== 4 || gate.schema !== 1 || typeof gate.generation !== "string" || !UUID.test(gate.generation) || typeof gate.version !== "string" || !VERSION.test(gate.version) || typeof gate.owner !== "string" || !UUID.test(gate.owner))
971
+ throw new Error("Invalid update launch gate");
972
+ return Object.freeze({
973
+ schema: 1,
974
+ generation: gate.generation,
975
+ version: gate.version,
976
+ owner: gate.owner
977
+ });
978
+ }
979
+ function parseGate(value) {
980
+ if (typeof value !== "object" || value === null || Array.isArray(value))
981
+ throw new Error("Invalid update launch gate");
982
+ const record = value;
983
+ if (Object.keys(record).length !== 4 || Object.keys(record).some((key) => !["schema", "generation", "version", "owner"].includes(key)))
984
+ throw new Error("Invalid update launch gate");
985
+ return validateGateInput(record);
986
+ }
987
+ async function readUpdateLaunchGate(target) {
988
+ const path = updateLaunchGatePath(target);
989
+ let info;
239
990
  try {
240
- renameUpdateExclusive(join2(staging, "candidate"), target);
991
+ info = await lstat3(path);
241
992
  } catch (error) {
242
- renameUpdateExclusive(old, target);
993
+ if (error.code === "ENOENT")
994
+ return;
243
995
  throw error;
244
996
  }
245
- await rm(old, { recursive: true, force: true });
997
+ if (!info.isFile() || info.isSymbolicLink() || info.size < 1 || info.size > MAX_GATE_BYTES)
998
+ throw new Error("Invalid update launch gate");
999
+ const file = await open5(path, constants5.O_RDONLY | (constants5.O_NOFOLLOW ?? 0));
1000
+ try {
1001
+ const opened = await file.stat();
1002
+ if (!opened.isFile() || opened.size < 1 || opened.size > MAX_GATE_BYTES)
1003
+ throw new Error("Invalid update launch gate");
1004
+ return parseGate(JSON.parse(await file.readFile("utf8")));
1005
+ } finally {
1006
+ await file.close();
1007
+ }
1008
+ }
1009
+ function sameGate(left, right) {
1010
+ return left?.schema === right.schema && left.generation === right.generation && left.version === right.version && left.owner === right.owner;
1011
+ }
1012
+ function createAsyncMutex() {
1013
+ let tail = Promise.resolve();
1014
+ return function serialize(operation) {
1015
+ const result = tail.then(operation);
1016
+ tail = result.then(() => {
1017
+ return;
1018
+ }, () => {
1019
+ return;
1020
+ });
1021
+ return result;
1022
+ };
1023
+ }
1024
+ async function publishUpdateLaunchGate(target, helperLiveness, input, persistOwner) {
1025
+ validateTarget(target);
1026
+ const helperState = helperLeaseState(helperLiveness, target, helperLiveness?.owner);
1027
+ if (helperState.state !== "available")
1028
+ throw new Error("Update helper liveness claim is already in use");
1029
+ const gate = validateGateInput({ schema: 1, ...input, owner: helperState.owner });
1030
+ helperState.state = "publishing";
1031
+ let pin;
1032
+ let lock;
1033
+ try {
1034
+ pin = await tryAcquireUpdateInstanceLease(target, "shared");
1035
+ if (!pin)
1036
+ throw new Error("Cannot publish an update launch gate during an install transition");
1037
+ lock = await acquireUpdateLock(target);
1038
+ const existing = await readUpdateLaunchGate(target);
1039
+ if (existing) {
1040
+ throw new Error("Another update helper owns the launch gate");
1041
+ }
1042
+ const path = updateLaunchGatePath(target);
1043
+ const temporary = join8(dirname5(path), `.${basename4(path)}.${gate.generation}.${randomUUID4()}.tmp`);
1044
+ let renamed = false;
1045
+ try {
1046
+ const file = await open5(temporary, constants5.O_WRONLY | constants5.O_CREAT | constants5.O_EXCL, 384);
1047
+ try {
1048
+ await file.writeFile(JSON.stringify(gate) + `
1049
+ `);
1050
+ await file.sync();
1051
+ } finally {
1052
+ await file.close();
1053
+ }
1054
+ await rename2(temporary, path);
1055
+ renamed = true;
1056
+ await syncDirectory(dirname5(path));
1057
+ } catch (error) {
1058
+ if (!renamed)
1059
+ await unlink3(temporary).catch(() => {});
1060
+ throw error;
1061
+ }
1062
+ await persistOwner?.(gate);
1063
+ const published = await readUpdateLaunchGate(target);
1064
+ if (!published || !sameGate(published, gate))
1065
+ throw new Error("Update launch gate publication could not be verified");
1066
+ return published;
1067
+ } finally {
1068
+ try {
1069
+ await lock?.release();
1070
+ } finally {
1071
+ try {
1072
+ await pin?.release();
1073
+ } finally {
1074
+ if (helperState.state === "publishing")
1075
+ helperState.state = "available";
1076
+ }
1077
+ }
1078
+ }
1079
+ }
1080
+ async function clearOwnedUpdateLaunchGate(target, expected, transitionCompleted, verifyPersistedTransition) {
1081
+ validateTarget(target);
1082
+ const gate = validateGateInput(expected);
1083
+ const lock = await acquireUpdateLock(target);
1084
+ try {
1085
+ if (!transitionCompleted())
1086
+ throw new Error("Update launch gate cannot clear before a successful transition");
1087
+ const current = await readUpdateLaunchGate(target);
1088
+ if (!current)
1089
+ return "absent";
1090
+ if (!sameGate(current, gate))
1091
+ return "ownership-mismatch";
1092
+ if (await verifyPersistedTransition(gate) !== true)
1093
+ return "unproven";
1094
+ const verified = await readUpdateLaunchGate(target);
1095
+ if (!verified)
1096
+ return "absent";
1097
+ if (!sameGate(verified, gate))
1098
+ return "ownership-mismatch";
1099
+ await unlink3(updateLaunchGatePath(target));
1100
+ await syncDirectory(dirname5(updateLaunchGatePath(target)));
1101
+ return "cleared";
1102
+ } finally {
1103
+ await lock.release();
1104
+ }
1105
+ }
1106
+ function throwIfAborted(signal) {
1107
+ if (!signal?.aborted)
1108
+ return;
1109
+ throw signal.reason ?? new DOMException("The operation was aborted", "AbortError");
1110
+ }
1111
+ var retainedBootstrapLeases = new Set;
1112
+ function sleep(ms, ...signals) {
1113
+ const activeSignals = signals.filter((signal) => signal !== undefined);
1114
+ if (activeSignals.length === 0)
1115
+ return Bun.sleep(ms);
1116
+ for (const signal of activeSignals)
1117
+ throwIfAborted(signal);
1118
+ return new Promise((resolveSleep, reject) => {
1119
+ let settled = false;
1120
+ const cleanup = () => {
1121
+ clearTimeout(timer);
1122
+ for (const [signal, onAbort] of listeners)
1123
+ signal.removeEventListener("abort", onAbort);
1124
+ };
1125
+ const listeners = activeSignals.map((signal) => {
1126
+ const onAbort = () => {
1127
+ if (settled)
1128
+ return;
1129
+ settled = true;
1130
+ cleanup();
1131
+ reject(signal.reason ?? new DOMException("The operation was aborted", "AbortError"));
1132
+ };
1133
+ return [signal, onAbort];
1134
+ });
1135
+ const timer = setTimeout(() => {
1136
+ if (settled)
1137
+ return;
1138
+ settled = true;
1139
+ cleanup();
1140
+ resolveSleep();
1141
+ }, ms);
1142
+ for (const [signal, onAbort] of listeners)
1143
+ signal.addEventListener("abort", onAbort, { once: true });
1144
+ });
1145
+ }
1146
+ async function waitForUpdateLaunchGateWriter(target, expected, options) {
1147
+ validateTarget(target);
1148
+ const gate = validateGateInput(expected);
1149
+ const pollIntervalMs = options.pollIntervalMs ?? 25;
1150
+ if (!Number.isSafeInteger(pollIntervalMs) || pollIntervalMs < 1 || pollIntervalMs > 1000)
1151
+ throw new Error("Invalid update launch gate polling interval");
1152
+ throwIfAborted(options.signal);
1153
+ const helperState = helperLeaseState(options.helperLiveness, target, gate.owner);
1154
+ if (helperState.state !== "available")
1155
+ throw new Error("Update helper liveness claim is already in use");
1156
+ helperState.state = "waiting";
1157
+ const waitController = new AbortController;
1158
+ let settleWait;
1159
+ const waitSettled = new Promise((resolveWait) => {
1160
+ settleWait = resolveWait;
1161
+ });
1162
+ helperState.cancelWait = () => waitController.abort(new Error("Update launch gate wait was cancelled"));
1163
+ helperState.waitSettled = waitSettled;
1164
+ const assertWaiting = () => {
1165
+ throwIfAborted(options.signal);
1166
+ throwIfAborted(waitController.signal);
1167
+ if (helperState.state !== "waiting")
1168
+ throw new Error("Update launch gate wait no longer owns the helper claim");
1169
+ };
1170
+ try {
1171
+ while (true) {
1172
+ assertWaiting();
1173
+ const preflightCoordinator = await tryAcquireUpdateLock(target);
1174
+ if (!preflightCoordinator) {
1175
+ assertWaiting();
1176
+ await sleep(pollIntervalMs, options.signal, waitController.signal);
1177
+ continue;
1178
+ }
1179
+ try {
1180
+ assertWaiting();
1181
+ const active = await readUpdateLaunchGate(target);
1182
+ if (!sameGate(active, gate))
1183
+ throw new Error("Update writer no longer owns the launch gate");
1184
+ assertWaiting();
1185
+ } finally {
1186
+ await preflightCoordinator.release();
1187
+ }
1188
+ assertWaiting();
1189
+ const instance = await tryAcquireUpdateInstanceLease(target, "exclusive");
1190
+ if (!instance) {
1191
+ assertWaiting();
1192
+ await sleep(pollIntervalMs, options.signal, waitController.signal);
1193
+ continue;
1194
+ }
1195
+ let coordinator;
1196
+ let keepInstance = false;
1197
+ try {
1198
+ assertWaiting();
1199
+ coordinator = await tryAcquireUpdateLock(target);
1200
+ assertWaiting();
1201
+ if (!coordinator) {
1202
+ await instance.release();
1203
+ await sleep(pollIntervalMs, options.signal, waitController.signal);
1204
+ continue;
1205
+ }
1206
+ const current = await readUpdateLaunchGate(target);
1207
+ if (!sameGate(current, gate))
1208
+ throw new Error("Update writer no longer owns the launch gate");
1209
+ if (await options.beforeWriterGrant?.())
1210
+ throw new Error("Update cancellation request precedes the writer grant");
1211
+ assertWaiting();
1212
+ helperState.writerGranted = true;
1213
+ helperState.state = "writer";
1214
+ keepInstance = true;
1215
+ await coordinator.release();
1216
+ coordinator = undefined;
1217
+ let released = false;
1218
+ let instanceReleased = false;
1219
+ let transitionCompleted = false;
1220
+ const serialize = createAsyncMutex();
1221
+ return {
1222
+ gate,
1223
+ withTransition(operation) {
1224
+ return serialize(async () => {
1225
+ if (released)
1226
+ throw new Error("Update writer lease has been released");
1227
+ transitionCompleted = false;
1228
+ const transition = await acquireUpdateLock(target);
1229
+ let result;
1230
+ try {
1231
+ const active = await readUpdateLaunchGate(target);
1232
+ if (!sameGate(active, gate))
1233
+ throw new Error("Update writer no longer owns the launch gate");
1234
+ result = await operation(gate);
1235
+ } finally {
1236
+ await transition.release();
1237
+ }
1238
+ transitionCompleted = true;
1239
+ return result;
1240
+ });
1241
+ },
1242
+ clearGate: (verifyPersistedTransition) => serialize(async () => {
1243
+ if (released)
1244
+ throw new Error("Update writer lease has been released");
1245
+ if (typeof verifyPersistedTransition !== "function")
1246
+ throw new Error("Update launch gate clearing requires persisted transition proof");
1247
+ return clearOwnedUpdateLaunchGate(target, gate, () => transitionCompleted, verifyPersistedTransition).then((result) => {
1248
+ if (result === "ownership-mismatch")
1249
+ throw new Error("Update writer no longer owns the launch gate");
1250
+ return result;
1251
+ });
1252
+ }),
1253
+ release: () => serialize(async () => {
1254
+ if (released)
1255
+ return;
1256
+ if (!instanceReleased) {
1257
+ await instance.release();
1258
+ instanceReleased = true;
1259
+ }
1260
+ helperState.state = "available";
1261
+ released = true;
1262
+ })
1263
+ };
1264
+ } finally {
1265
+ try {
1266
+ await coordinator?.release();
1267
+ } finally {
1268
+ if (!keepInstance)
1269
+ await instance.release();
1270
+ }
1271
+ }
1272
+ }
1273
+ } finally {
1274
+ if (helperState.state === "waiting")
1275
+ helperState.state = "available";
1276
+ if (helperState.waitSettled === waitSettled) {
1277
+ helperState.waitSettled = undefined;
1278
+ helperState.cancelWait = undefined;
1279
+ }
1280
+ settleWait();
1281
+ }
246
1282
  }
247
1283
 
248
1284
  // src/updates/update-helper.ts
249
1285
  function parseUpdateHelperRequest(value) {
250
1286
  const data = value;
251
- if (typeof value !== "object" || value === null || Array.isArray(value) || data.schema !== 1 || typeof data.target !== "string" || !isAbsolute5(data.target) || resolve4(data.target) !== data.target || !["macos-arm64", "windows-x64", "linux-x64"].includes(data.platform) || typeof data.version !== "string" || !/^\d+\.\d+\.\d+(?:-dev\.\d+)?$/.test(data.version) || !Array.isArray(data.processes) || !Number.isSafeInteger(data.processTimeoutMs) || data.processTimeoutMs < 1 || data.processTimeoutMs > 120000)
1287
+ if (typeof value !== "object" || value === null || Array.isArray(value) || data.schema !== 1 && data.schema !== 2 && data.schema !== 3 || typeof data.target !== "string" || !isAbsolute8(data.target) || resolve7(data.target) !== data.target || !["macos-arm64", "windows-x64", "linux-x64"].includes(data.platform) || typeof data.version !== "string" || !/^\d+\.\d+\.\d+(?:-dev\.\d+)?$/.test(data.version) || !Array.isArray(data.processes) || data.schema === 2 && (typeof data.generation !== "string" || !/^[0-9a-f-]{36}$/i.test(data.generation) || data.helperOwner !== undefined && (typeof data.helperOwner !== "string" || !/^[0-9a-f-]{36}$/i.test(data.helperOwner))) || data.schema === 3 && (typeof data.generation !== "string" || !/^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(data.generation) || typeof data.helperOwner !== "string" || !/^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(data.helperOwner)) || !Number.isSafeInteger(data.processTimeoutMs) || data.processTimeoutMs < 1 || data.processTimeoutMs > 120000)
252
1288
  throw new Error("Invalid update helper request");
253
1289
  return Object.freeze(data);
254
1290
  }
255
1291
  async function readRequest(staging) {
256
- const path = join3(staging, "request.json"), info = await lstat(path);
1292
+ const path = join9(staging, "request.json"), info = await lstat4(path);
257
1293
  if (!info.isFile() || info.size < 1 || info.size > 65536)
258
1294
  throw new Error("Invalid update helper request");
259
- const file = await open(path, constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0));
1295
+ const file = await open6(path, constants6.O_RDONLY | (constants6.O_NOFOLLOW ?? 0));
260
1296
  try {
261
1297
  return parseUpdateHelperRequest(JSON.parse(await file.readFile("utf8")));
262
1298
  } finally {
263
1299
  await file.close();
264
1300
  }
265
1301
  }
1302
+ async function cancellationRequested(staging, generation, helperOwner) {
1303
+ const value = await readUpdateMarker(staging, "cancel.json");
1304
+ if (!value)
1305
+ return false;
1306
+ if (value.schema !== 1 || value.generation !== generation || value.helperOwner !== helperOwner)
1307
+ throw new Error("Update helper cancellation request does not match its generation");
1308
+ return true;
1309
+ }
1310
+ async function acknowledgeUpdateCancellation(staging, request) {
1311
+ if (request.schema !== 2 && request.schema !== 3 || !request.generation || !request.helperOwner)
1312
+ throw new Error("Update helper cancellation owner is unavailable");
1313
+ const current = await readUpdateStageState(staging);
1314
+ if (!current || current.phase !== "armed" || current.helperPid !== process.pid || current.generation !== request.generation || request.schema === 3 && current.helperOwner !== request.helperOwner || request.schema === 3 && !current.launchGateOwner || !await cancellationRequested(staging, request.generation, request.helperOwner))
1315
+ throw new Error("Update helper cannot acknowledge a cancellation it no longer owns");
1316
+ await publishExclusiveUpdateMarker(staging, "cancel-ack.json", {
1317
+ schema: 1,
1318
+ generation: request.generation,
1319
+ helperOwner: request.helperOwner,
1320
+ ...request.schema === 3 ? { launchGateOwner: current.launchGateOwner } : {}
1321
+ });
1322
+ }
1323
+ async function updatePathExists(path) {
1324
+ try {
1325
+ await lstat4(path);
1326
+ return true;
1327
+ } catch (error) {
1328
+ if (error.code === "ENOENT")
1329
+ return false;
1330
+ throw error;
1331
+ }
1332
+ }
266
1333
  async function runUpdateHelper(options) {
1334
+ const hasBoundIdentity = options.target !== undefined || options.generation !== undefined || options.helperOwner !== undefined;
1335
+ if (hasBoundIdentity) {
1336
+ if (typeof options.target !== "string" || !isAbsolute8(options.target) || resolve7(options.target) !== options.target || options.target.includes("\x00") || !isAbsolute8(options.staging) || resolve7(options.staging) !== options.staging || options.staging.includes("\x00") || updateStagingFor(options.target) !== options.staging || typeof options.generation !== "string" || !/^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(options.generation) || typeof options.helperOwner !== "string" || !/^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(options.helperOwner))
1337
+ throw new Error("Invalid update helper invocation");
1338
+ const liveness = await tryAcquireUpdateHelperLiveness(options.target);
1339
+ if (!liveness)
1340
+ throw new Error("Update helper liveness is already owned");
1341
+ try {
1342
+ const stagingInfo = await lstat4(options.staging);
1343
+ if (!stagingInfo.isDirectory() || stagingInfo.isSymbolicLink() || await realpath2(options.staging) !== options.staging)
1344
+ throw new Error("Invalid update staging directory");
1345
+ const request = await readRequest(options.staging);
1346
+ if (request.schema !== 3 || request.target !== options.target || request.generation !== options.generation || request.helperOwner !== options.helperOwner)
1347
+ throw new Error("Update helper request does not match its command-line owner");
1348
+ return await runUpdateHelperWithRequest(options, request, {
1349
+ target: options.target,
1350
+ generation: options.generation,
1351
+ helperOwner: options.helperOwner
1352
+ }, liveness);
1353
+ } finally {
1354
+ await liveness.release();
1355
+ }
1356
+ }
267
1357
  const request = await readRequest(options.staging);
1358
+ if (request.schema === 3)
1359
+ throw new Error("Schema 3 update helper requires command-line ownership binding");
1360
+ return runUpdateHelperWithRequest(options, request);
1361
+ }
1362
+ async function runUpdateHelperWithRequest(options, request, binding, helperLiveness) {
268
1363
  if (updateStagingFor(request.target) !== options.staging)
269
1364
  throw new Error("Update helper request does not match its staging directory");
1365
+ if (binding && (request.target !== binding.target || request.generation !== binding.generation || request.helperOwner !== binding.helperOwner))
1366
+ throw new Error("Update helper request does not match its command-line owner");
1367
+ if (request.schema === 3) {
1368
+ if (!binding || !helperLiveness)
1369
+ throw new Error("Schema 3 update helper requires liveness-bound gate ownership");
1370
+ return runSchema3UpdateHelper(options, request, helperLiveness);
1371
+ }
1372
+ const lock = await acquireUpdateLock(request.target);
1373
+ let state;
1374
+ try {
1375
+ state = await readUpdateStageState(options.staging);
1376
+ if (!state || state.phase !== "armed" || state.helperPid !== process.pid || state.version !== request.version || request.schema === 2 && state.generation !== request.generation)
1377
+ throw new Error("Update helper no longer owns this staging directory");
1378
+ } finally {
1379
+ await lock.release();
1380
+ }
1381
+ let cancelled = false;
270
1382
  await waitForUpdateProcesses({
271
1383
  processes: request.processes,
272
1384
  timeoutMs: request.processTimeoutMs,
273
- onVerified: () => writeFileSync(join3(options.staging, "helper-armed"), String(process.pid), {
274
- flag: "wx",
275
- mode: 384
1385
+ ...request.schema === 2 && request.generation && request.helperOwner ? {
1386
+ cancellationRequested: () => cancellationRequested(options.staging, request.generation, request.helperOwner)
1387
+ } : {},
1388
+ onVerified: () => publishExclusiveUpdateMarkerSync(options.staging, "helper-ready", {
1389
+ schema: 1,
1390
+ generation: state.generation,
1391
+ helperOwner: request.helperOwner ?? ""
276
1392
  })
1393
+ }).catch(async (error) => {
1394
+ if (error instanceof UpdateProcessFenceCancelledError && request.schema === 2 && request.generation && request.helperOwner) {
1395
+ const cancellationLock = await acquireUpdateLock(request.target);
1396
+ try {
1397
+ await acknowledgeUpdateCancellation(options.staging, request);
1398
+ cancelled = true;
1399
+ } finally {
1400
+ await cancellationLock.release();
1401
+ }
1402
+ return;
1403
+ }
1404
+ throw error;
277
1405
  });
1406
+ if (cancelled)
1407
+ return "cancelled";
278
1408
  let outcome = "failed";
1409
+ const swapLock = await acquireUpdateLock(request.target);
279
1410
  try {
280
- await swapUpdateTree({ target: request.target, staging: options.staging });
281
- await writeFile(join3(options.staging, "updated"), request.version, { mode: 384 });
1411
+ const current = await readUpdateStageState(options.staging);
1412
+ if (!current || current.phase !== "armed" || current.helperPid !== process.pid || current.generation !== state?.generation)
1413
+ throw new Error("Update helper ownership changed before swap");
1414
+ if (request.schema === 2 && request.generation && request.helperOwner && await cancellationRequested(options.staging, request.generation, request.helperOwner)) {
1415
+ await acknowledgeUpdateCancellation(options.staging, request);
1416
+ return "cancelled";
1417
+ }
1418
+ const candidate = join9(options.staging, "candidate");
1419
+ if (await readUpdateTreeVersion(request.target) !== current.previousVersion || await readUpdateTreeVersion(candidate) !== current.version || !sameUpdateTreeIdentity(await readUpdateTreeIdentity(candidate), current.candidateTreeIdentity))
1420
+ throw new Error("Installed and candidate versions do not match the staged update");
1421
+ const previousTreeIdentity = await readUpdateTreeIdentity(request.target);
1422
+ if (!previousTreeIdentity)
1423
+ throw new Error("Installed update tree identity could not be read");
1424
+ const swapping = {
1425
+ ...current,
1426
+ phase: "swapping",
1427
+ previousTreeIdentity
1428
+ };
1429
+ await writeUpdateStageState(options.staging, swapping);
1430
+ await swapUpdateTreeWhileLocked({
1431
+ target: request.target,
1432
+ staging: options.staging
1433
+ });
1434
+ if (await readUpdateTreeVersion(request.target) !== swapping.version || await readUpdateTreeVersion(join9(options.staging, "candidate")) !== swapping.previousVersion || !sameUpdateTreeIdentity(await readUpdateTreeIdentity(request.target), swapping.candidateTreeIdentity) || !sameUpdateTreeIdentity(await readUpdateTreeIdentity(join9(options.staging, "candidate")), swapping.previousTreeIdentity))
1435
+ throw new Error("Atomic update exchange produced unexpected tree versions");
1436
+ await writeUpdateStageState(options.staging, { ...swapping, phase: "completed" });
282
1437
  outcome = "updated";
283
- } catch {}
1438
+ } catch {
1439
+ const current = await readUpdateStageState(options.staging).catch(() => {
1440
+ return;
1441
+ });
1442
+ if (current?.phase === "armed" && request.schema === 2 && request.generation && request.helperOwner && await updatePathExists(join9(options.staging, "cancel.json")).catch(() => false))
1443
+ throw new Error("Update helper could not acknowledge cancellation before the install transition");
1444
+ } finally {
1445
+ await swapLock.release();
1446
+ }
284
1447
  await launchInstalledApp(request.platform, request.target, options.env);
285
1448
  return outcome;
286
1449
  }
1450
+ async function matchesArmedGateTree(target, staging, request, gate) {
1451
+ const state = await readUpdateStageState(staging);
1452
+ if (!state || state.phase !== "armed" || state.helperPid !== process.pid || state.generation !== request.generation || state.version !== request.version || state.helperOwner !== request.helperOwner || state.launchGateOwner !== gate.owner || !state.previousTreeIdentity || !state.candidateTreeDigest || gate.generation !== state.generation || gate.version !== state.version)
1453
+ return false;
1454
+ const candidate = join9(staging, "candidate");
1455
+ const [installedVersion, candidateVersion, installedIdentity, candidateIdentity] = await Promise.all([
1456
+ readUpdateTreeVersion(target),
1457
+ readUpdateTreeVersion(candidate),
1458
+ readUpdateTreeIdentity(target),
1459
+ readUpdateTreeIdentity(candidate)
1460
+ ]);
1461
+ return installedVersion === state.previousVersion && candidateVersion === state.version && sameUpdateTreeIdentity(installedIdentity, state.previousTreeIdentity) && sameUpdateTreeIdentity(candidateIdentity, state.candidateTreeIdentity) && sameUpdateTreeDigest(await readUpdateTreeDigest(candidate), state.candidateTreeDigest);
1462
+ }
1463
+ async function acknowledgeSchema3Cancellation(options, request) {
1464
+ const lock = await acquireUpdateLock(request.target);
1465
+ try {
1466
+ await acknowledgeUpdateCancellation(options.staging, request);
1467
+ } finally {
1468
+ await lock.release();
1469
+ }
1470
+ }
1471
+ async function waitForSchema3GateWriter(options, request, helperLiveness, gate) {
1472
+ const controller = new AbortController;
1473
+ let watcherStopped = false;
1474
+ let cancellationObserved = false;
1475
+ let watchError;
1476
+ const watcher = (async () => {
1477
+ for (;; ) {
1478
+ if (watcherStopped)
1479
+ break;
1480
+ try {
1481
+ if (await cancellationRequested(options.staging, request.generation, request.helperOwner)) {
1482
+ cancellationObserved = true;
1483
+ controller.abort(new Error("Update helper cancellation was requested"));
1484
+ return;
1485
+ }
1486
+ } catch (error) {
1487
+ watchError = error;
1488
+ controller.abort(error);
1489
+ return;
1490
+ }
1491
+ await Bun.sleep(20);
1492
+ }
1493
+ })();
1494
+ let writer;
1495
+ let waitError;
1496
+ try {
1497
+ writer = await waitForUpdateLaunchGateWriter(request.target, gate, {
1498
+ helperLiveness,
1499
+ signal: controller.signal,
1500
+ beforeWriterGrant: () => cancellationRequested(options.staging, request.generation, request.helperOwner)
1501
+ });
1502
+ } catch (error) {
1503
+ waitError = error;
1504
+ }
1505
+ watcherStopped = true;
1506
+ await watcher;
1507
+ if (watchError !== undefined) {
1508
+ await writer?.release().catch(() => {});
1509
+ throw watchError;
1510
+ }
1511
+ const cancellationIsRequested = cancellationObserved || await cancellationRequested(options.staging, request.generation, request.helperOwner);
1512
+ if (cancellationIsRequested) {
1513
+ if (writer) {
1514
+ let result;
1515
+ try {
1516
+ result = await cancelUpdateLaunchGateBeforeTransition(request.target, helperLiveness, gate, (active) => matchesArmedGateTree(request.target, options.staging, request, active));
1517
+ } finally {
1518
+ await writer.release();
1519
+ }
1520
+ if (result === "cleared")
1521
+ return { status: "cancelled" };
1522
+ throw new Error("Update cancellation arrived after the helper acquired the writer lease");
1523
+ }
1524
+ const result = await cancelUpdateLaunchGateBeforeTransition(request.target, helperLiveness, gate, (active) => matchesArmedGateTree(request.target, options.staging, request, active));
1525
+ if (result === "cleared")
1526
+ return { status: "cancelled" };
1527
+ throw new Error("Update helper could not safely clear its launch gate for cancellation");
1528
+ }
1529
+ if (waitError !== undefined)
1530
+ throw waitError;
1531
+ if (!writer)
1532
+ throw new Error("Update launch gate writer was not acquired");
1533
+ return { status: "writer", writer };
1534
+ }
1535
+ async function runSchema3UpdateHelper(options, request, helperLiveness) {
1536
+ const initialLock = await acquireUpdateLock(request.target);
1537
+ try {
1538
+ const current = await readUpdateStageState(options.staging);
1539
+ if (!current || current.phase !== "armed" || current.helperPid !== process.pid || current.version !== request.version || current.generation !== request.generation || current.helperOwner !== request.helperOwner || !current.candidateTreeDigest)
1540
+ throw new Error("Update helper no longer owns this staging directory");
1541
+ } finally {
1542
+ await initialLock.release();
1543
+ }
1544
+ const gate = await publishUpdateLaunchGate(request.target, helperLiveness, { generation: request.generation, version: request.version }, async (published) => {
1545
+ const current = await readUpdateStageState(options.staging);
1546
+ if (!current || current.phase !== "armed" || current.helperPid !== process.pid || current.generation !== request.generation || current.version !== request.version || current.helperOwner !== request.helperOwner || current.launchGateOwner !== undefined)
1547
+ throw new Error("Update helper ownership changed during gate publication");
1548
+ const candidate = join9(options.staging, "candidate");
1549
+ const [installedVersion, candidateVersion, installedIdentity, candidateIdentity] = await Promise.all([
1550
+ readUpdateTreeVersion(request.target),
1551
+ readUpdateTreeVersion(candidate),
1552
+ readUpdateTreeIdentity(request.target),
1553
+ readUpdateTreeIdentity(candidate)
1554
+ ]);
1555
+ const candidateDigest = await readUpdateTreeDigest(candidate);
1556
+ if (installedVersion !== current.previousVersion || candidateVersion !== current.version || !installedIdentity || !sameUpdateTreeIdentity(candidateIdentity, current.candidateTreeIdentity) || !sameUpdateTreeDigest(candidateDigest, current.candidateTreeDigest))
1557
+ throw new Error("Update helper cannot publish a gate for changed update trees");
1558
+ await writeUpdateStageStateDurably(options.staging, {
1559
+ ...current,
1560
+ previousTreeIdentity: installedIdentity,
1561
+ launchGateOwner: published.owner
1562
+ });
1563
+ });
1564
+ const mapped = await readUpdateStageState(options.staging);
1565
+ if (!mapped || mapped.phase !== "armed" || mapped.generation !== gate.generation || mapped.version !== gate.version || mapped.helperPid !== process.pid || mapped.helperOwner !== request.helperOwner || mapped.launchGateOwner !== gate.owner || !mapped.previousTreeIdentity || !mapped.candidateTreeDigest)
1566
+ throw new Error("Update helper gate owner was not durably recorded");
1567
+ let cancelled = false;
1568
+ try {
1569
+ await waitForUpdateProcesses({
1570
+ processes: request.processes,
1571
+ timeoutMs: request.processTimeoutMs,
1572
+ cancellationRequested: () => cancellationRequested(options.staging, request.generation, request.helperOwner),
1573
+ onVerified: () => publishExclusiveUpdateMarkerSync(options.staging, "helper-ready", {
1574
+ schema: 1,
1575
+ generation: gate.generation,
1576
+ helperOwner: request.helperOwner,
1577
+ launchGateOwner: gate.owner
1578
+ })
1579
+ });
1580
+ } catch (error) {
1581
+ if (!(error instanceof UpdateProcessFenceCancelledError))
1582
+ throw error;
1583
+ const result = await cancelUpdateLaunchGateBeforeTransition(request.target, helperLiveness, gate, (active) => matchesArmedGateTree(request.target, options.staging, request, active));
1584
+ if (result !== "cleared")
1585
+ throw new Error("Update helper could not safely clear its launch gate for cancellation", {
1586
+ cause: error
1587
+ });
1588
+ await acknowledgeSchema3Cancellation(options, request);
1589
+ cancelled = true;
1590
+ }
1591
+ if (cancelled)
1592
+ return "cancelled";
1593
+ const waiting = await waitForSchema3GateWriter(options, request, helperLiveness, gate);
1594
+ if (waiting.status === "cancelled") {
1595
+ await acknowledgeSchema3Cancellation(options, request);
1596
+ return "cancelled";
1597
+ }
1598
+ const writer = waiting.writer;
1599
+ const candidate = join9(options.staging, "candidate");
1600
+ let completedDigestVerified = false;
1601
+ try {
1602
+ await syncUpdateTree(candidate);
1603
+ await syncUpdateTreeParent(candidate);
1604
+ const transitionResult = await writer.withTransition(async (active) => {
1605
+ const current = await readUpdateStageState(options.staging);
1606
+ if (!current || current.phase !== "armed" || current.helperPid !== process.pid || current.generation !== gate.generation || current.version !== gate.version || current.helperOwner !== request.helperOwner || current.launchGateOwner !== gate.owner || !current.previousTreeIdentity || !current.candidateTreeDigest || await readUpdateTreeVersion(request.target) !== current.previousVersion || await readUpdateTreeVersion(candidate) !== current.version || !sameUpdateTreeIdentity(await readUpdateTreeIdentity(request.target), current.previousTreeIdentity) || !sameUpdateTreeIdentity(await readUpdateTreeIdentity(candidate), current.candidateTreeIdentity) || !sameUpdateTreeDigest(await readUpdateTreeDigest(candidate), current.candidateTreeDigest))
1607
+ throw new Error("Update helper ownership or tree identity changed before swap");
1608
+ if (active.owner !== gate.owner)
1609
+ throw new Error("Update writer owner changed");
1610
+ const swapping = { ...current, phase: "swapping" };
1611
+ await writeUpdateStageStateDurably(options.staging, swapping);
1612
+ await swapUpdateTreeWhileLocked({ target: request.target, staging: options.staging });
1613
+ await syncUpdateTreeParent(candidate);
1614
+ await syncUpdateTreeParent(request.target);
1615
+ if (await readUpdateTreeVersion(request.target) !== swapping.version || await readUpdateTreeVersion(candidate) !== swapping.previousVersion || !sameUpdateTreeIdentity(await readUpdateTreeIdentity(request.target), swapping.candidateTreeIdentity) || !sameUpdateTreeIdentity(await readUpdateTreeIdentity(candidate), swapping.previousTreeIdentity))
1616
+ throw new Error("Atomic update exchange produced unexpected tree versions");
1617
+ if (!sameUpdateTreeDigest(await readUpdateTreeDigest(request.target), swapping.candidateTreeDigest))
1618
+ throw new Error("Installed update tree content changed during the directory exchange");
1619
+ completedDigestVerified = true;
1620
+ await writeUpdateStageStateDurably(options.staging, { ...swapping, phase: "completed" });
1621
+ return "updated";
1622
+ });
1623
+ const cleared = await writer.clearGate(async (active) => {
1624
+ const current = await readUpdateStageState(options.staging);
1625
+ if (!current || current.phase !== "completed" || current.helperPid !== process.pid || current.generation !== active.generation || current.version !== active.version || current.helperOwner !== request.helperOwner || current.launchGateOwner !== active.owner || !current.previousTreeIdentity || !current.candidateTreeDigest)
1626
+ return false;
1627
+ const [installedVersion, previousVersion, installedIdentity, previousIdentity] = await Promise.all([
1628
+ readUpdateTreeVersion(request.target),
1629
+ readUpdateTreeVersion(candidate),
1630
+ readUpdateTreeIdentity(request.target),
1631
+ readUpdateTreeIdentity(candidate)
1632
+ ]);
1633
+ return installedVersion === current.version && previousVersion === current.previousVersion && sameUpdateTreeIdentity(installedIdentity, current.candidateTreeIdentity) && sameUpdateTreeIdentity(previousIdentity, current.previousTreeIdentity) && completedDigestVerified;
1634
+ });
1635
+ if (cleared !== "cleared")
1636
+ throw new Error("Completed update could not prove safe launch gate removal");
1637
+ await writer.release();
1638
+ if (transitionResult !== "updated")
1639
+ throw new Error("Update transition did not complete");
1640
+ } catch {
1641
+ await writer.release().catch(() => {});
1642
+ return "failed";
1643
+ }
1644
+ await launchInstalledApp(request.platform, request.target, options.env);
1645
+ return "updated";
1646
+ }
287
1647
 
288
1648
  // src/cli/update-helper-cli.ts
289
- var index = process.argv.indexOf("--staging");
290
- var staging = index > 0 ? process.argv[index + 1] : undefined;
291
- if (!staging) {
292
- console.error("Usage: update-helper --staging <directory>");
1649
+ var values = new Map;
1650
+ var argv = process.argv.slice(2);
1651
+ var invalid = argv.length % 2 !== 0;
1652
+ for (let index = 0;index < argv.length; index += 2) {
1653
+ const key = argv[index];
1654
+ const value = argv[index + 1];
1655
+ if (key !== "--staging" && key !== "--target" && key !== "--generation" && key !== "--owner" || !value || value.startsWith("--") || values.has(key)) {
1656
+ invalid = true;
1657
+ break;
1658
+ }
1659
+ values.set(key, value);
1660
+ }
1661
+ var staging = values.get("--staging");
1662
+ var target = values.get("--target");
1663
+ var generation = values.get("--generation");
1664
+ var helperOwner = values.get("--owner");
1665
+ var hasBinding = target !== undefined || generation !== undefined || helperOwner !== undefined;
1666
+ if (invalid || !staging || hasBinding && (!target || !generation || !helperOwner) || !hasBinding && values.size !== 1) {
1667
+ console.error("Usage: update-helper --staging <directory> [--target <path> --generation <uuid> --owner <uuid>]");
293
1668
  process.exit(2);
294
1669
  }
295
- var outcome = await runUpdateHelper({ staging }).catch(() => "failed");
296
- process.exit(outcome === "updated" ? 0 : 1);
1670
+ var outcome = await runUpdateHelper({
1671
+ staging,
1672
+ ...hasBinding ? { target, generation, helperOwner } : {}
1673
+ }).catch(() => "failed");
1674
+ process.exit(outcome === "updated" || outcome === "cancelled" ? 0 : 1);