Skip to content

Commit 5309bf4

Browse files
fix(windows): settle scheduler registration verification
1 parent aae9426 commit 5309bf4

2 files changed

Lines changed: 188 additions & 1 deletion

File tree

‎src/service.ts‎

Lines changed: 38 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -664,6 +664,8 @@ type FinalizeHooks = {
664664
deleteArgs: string[],
665665
) => Promise<ElevatedSchtasksCreateAndRunResult>;
666666
verify?: () => WindowsSchedulerInstallVerification;
667+
/** Test-only replacement for the bounded post-registration settle delay. */
668+
settleDelay?: (milliseconds: number) => Promise<void>;
667669
writeInstallState?: () => void;
668670
/** Preferred tri-state probe for security-sensitive reconciliation. */
669671
probeTask?: () => WindowsSchedulerTaskProbe;
@@ -736,6 +738,36 @@ function attemptStillOwned(options: ApplyElevatedOptions): boolean {
736738
return !check || check(options.attemptId);
737739
}
738740

741+
const WINDOWS_SCHEDULER_VERIFICATION_SETTLE_DELAYS_MS = [50, 150, 300, 600] as const;
742+
743+
function schedulerVerificationMaySettle(
744+
verification: WindowsSchedulerInstallVerification,
745+
): boolean {
746+
return verification.assetsHealthy
747+
&& verification.nativeServiceAbsent
748+
&& !verification.nativeStatusUnknown
749+
&& !verification.conflict
750+
&& (!verification.taskInstalled || !verification.registrationHealthy);
751+
}
752+
753+
async function verifyWindowsSchedulerInstallAfterSettle(
754+
options: ApplyElevatedOptions,
755+
): Promise<WindowsSchedulerInstallVerification | null> {
756+
const verify = finalizeHooks?.verify ?? verifyWindowsSchedulerInstall;
757+
const delay = finalizeHooks?.settleDelay
758+
?? ((milliseconds: number) => new Promise<void>(resolve => setTimeout(resolve, milliseconds)));
759+
if (!attemptStillOwned(options)) return null;
760+
let verification = verify();
761+
for (const milliseconds of WINDOWS_SCHEDULER_VERIFICATION_SETTLE_DELAYS_MS) {
762+
if (verification.ok || !schedulerVerificationMaySettle(verification)) break;
763+
if (!attemptStillOwned(options)) return null;
764+
await delay(milliseconds);
765+
if (!attemptStillOwned(options)) return null;
766+
verification = verify();
767+
}
768+
return attemptStillOwned(options) ? verification : null;
769+
}
770+
739771
async function applyElevatedSchedulerResult(
740772
result: ElevatedSchtasksCreateAndRunResult,
741773
options: ApplyElevatedOptions,
@@ -765,7 +797,11 @@ async function applyElevatedSchedulerResult(
765797
await reconcileUnknownElevatedOutcome(result.exitCode);
766798
}
767799

768-
const verification = (finalizeHooks?.verify ?? verifyWindowsSchedulerInstall)();
800+
// Task Scheduler can acknowledge elevated creation before the non-elevated
801+
// query/XML view is coherent. Settle only that narrow visibility window;
802+
// conflicts, missing assets, and unknown SCM state still fail immediately.
803+
const verification = await verifyWindowsSchedulerInstallAfterSettle(options);
804+
if (!verification) return;
769805
if (!verification.ok) {
770806
// Preserve a healthy elevated task when WinSW absence cannot be proven (unknown SCM status).
771807
// Unknown is not a confirmed dual-backend conflict; install state is still withheld.
@@ -782,6 +818,7 @@ async function applyElevatedSchedulerResult(
782818
"Installation state was not written.",
783819
]);
784820
}
821+
if (!attemptStillOwned(options)) return;
785822
const rollbackError = await rollbackElevatedSchedulerTask();
786823
const parts = [
787824
"Elevated Task Scheduler registration did not produce a conflict-free install.",

‎tests/windows-elevation-spawn.test.ts‎

Lines changed: 150 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -319,6 +319,156 @@ describe("finalizeWindowsSchedulerServiceRegistration", () => {
319319
expect(parentRollbackLaunches).toBe(0);
320320
});
321321

322+
test("settles a transient post-create registration view before writing install state", async () => {
323+
let verifies = 0;
324+
const delays: number[] = [];
325+
setFinalizeWindowsSchedulerHooksForTests({
326+
elevateCreateAndRun: async () => ({
327+
outcome: "success",
328+
exitCode: OCX_ELEVATED_SUCCESS,
329+
stdout: "",
330+
stderr: "",
331+
}),
332+
verify: () => {
333+
verifies += 1;
334+
if (verifies < 3) {
335+
return {
336+
taskInstalled: verifies === 2,
337+
registrationHealthy: false,
338+
assetsHealthy: true,
339+
nativeServiceAbsent: true,
340+
nativeStatusUnknown: false,
341+
conflict: false,
342+
ok: false,
343+
detail: verifies === 1
344+
? "Task Scheduler task is not installed."
345+
: "Task Scheduler registration is present but unhealthy.",
346+
};
347+
}
348+
return okVerify();
349+
},
350+
settleDelay: async milliseconds => { delays.push(milliseconds); },
351+
writeInstallState: () => { writeCount += 1; },
352+
});
353+
354+
await expect(finalizeWindowsSchedulerServiceRegistration()).resolves.toEqual({ kind: "done" });
355+
expect(verifies).toBe(3);
356+
expect(delays).toEqual([50, 150]);
357+
expect(writeCount).toBe(1);
358+
expect(parentRollbackLaunches).toBe(0);
359+
});
360+
361+
test("does not settle a confirmed scheduler conflict", async () => {
362+
let verifies = 0;
363+
let delays = 0;
364+
mockParentRollbackSpawn();
365+
setFinalizeWindowsSchedulerHooksForTests({
366+
elevateCreateAndRun: async () => ({
367+
outcome: "success",
368+
exitCode: OCX_ELEVATED_SUCCESS,
369+
stdout: "",
370+
stderr: "",
371+
}),
372+
verify: () => {
373+
verifies += 1;
374+
return {
375+
taskInstalled: true,
376+
registrationHealthy: true,
377+
assetsHealthy: true,
378+
nativeServiceAbsent: false,
379+
nativeStatusUnknown: false,
380+
conflict: true,
381+
ok: false,
382+
detail: "CONFLICT: Task Scheduler and native WinSW are both present.",
383+
};
384+
},
385+
settleDelay: async () => { delays += 1; },
386+
writeInstallState: () => { writeCount += 1; },
387+
taskInstalled: () => false,
388+
});
389+
390+
await expect(finalizeWindowsSchedulerServiceRegistration()).rejects.toThrow(/CONFLICT/);
391+
expect(verifies).toBe(1);
392+
expect(delays).toBe(0);
393+
expect(writeCount).toBe(0);
394+
expect(parentRollbackLaunches).toBe(1);
395+
});
396+
397+
test("bounds settling when the registration remains unhealthy", async () => {
398+
let verifies = 0;
399+
const delays: number[] = [];
400+
mockParentRollbackSpawn();
401+
setFinalizeWindowsSchedulerHooksForTests({
402+
elevateCreateAndRun: async () => ({
403+
outcome: "success",
404+
exitCode: OCX_ELEVATED_SUCCESS,
405+
stdout: "",
406+
stderr: "",
407+
}),
408+
verify: () => {
409+
verifies += 1;
410+
return {
411+
taskInstalled: true,
412+
registrationHealthy: false,
413+
assetsHealthy: true,
414+
nativeServiceAbsent: true,
415+
nativeStatusUnknown: false,
416+
conflict: false,
417+
ok: false,
418+
detail: "Task Scheduler registration is present but unhealthy.",
419+
};
420+
},
421+
settleDelay: async milliseconds => { delays.push(milliseconds); },
422+
writeInstallState: () => { writeCount += 1; },
423+
taskInstalled: () => false,
424+
});
425+
426+
await expect(finalizeWindowsSchedulerServiceRegistration()).rejects.toThrow(/present but unhealthy/);
427+
expect(verifies).toBe(5);
428+
expect(delays).toEqual([50, 150, 300, 600]);
429+
expect(writeCount).toBe(0);
430+
expect(parentRollbackLaunches).toBe(1);
431+
});
432+
433+
test("stops settling without rollback or state write after attempt ownership is lost", async () => {
434+
let verifies = 0;
435+
let owned = true;
436+
const delays: number[] = [];
437+
setFinalizeWindowsSchedulerHooksForTests({
438+
elevateCreateAndRun: async () => ({
439+
outcome: "success",
440+
exitCode: OCX_ELEVATED_SUCCESS,
441+
stdout: "",
442+
stderr: "",
443+
}),
444+
verify: () => {
445+
verifies += 1;
446+
return {
447+
taskInstalled: false,
448+
registrationHealthy: false,
449+
assetsHealthy: true,
450+
nativeServiceAbsent: true,
451+
nativeStatusUnknown: false,
452+
conflict: false,
453+
ok: false,
454+
detail: "Task Scheduler task is not installed.",
455+
};
456+
},
457+
settleDelay: async milliseconds => {
458+
delays.push(milliseconds);
459+
owned = false;
460+
},
461+
stillOwnsAttempt: () => owned,
462+
writeInstallState: () => { writeCount += 1; },
463+
});
464+
465+
await expect(finalizeWindowsSchedulerServiceRegistration()).resolves.toEqual({ kind: "done" });
466+
expect(verifies).toBe(1);
467+
expect(delays).toEqual([50]);
468+
expect(writeCount).toBe(0);
469+
expect(parentRollbackLaunches).toBe(0);
470+
});
471+
322472
test("create failure does not write install state or parent-rollback", async () => {
323473
setFinalizeWindowsSchedulerHooksForTests({
324474
elevateCreateAndRun: async () => {

0 commit comments

Comments
 (0)