The best way to control Claude Code, Codex and more from any computer or phone
Mirrored from https://github.com/Camo67/t3code.git
Synced Nov 22, 02:00 UTC
fix(release): Windows signing retries transient Azure Trusted Signing errors (#33148)
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
Theo Browne committed
Nov 8, 2026 at 18:17 UTC
35675bf671164525ed76b4c9214c5a44c905d989
2 files changed
+239
-28
scripts/lib/windows-jsign.test.ts
new
+152
@@ -0,0 +1,152 @@
1
+import * as NodeServices from "@effect/platform-node/NodeServices";
2
+import { assert, it } from "@effect/vitest";
3
+import * as Cause from "effect/Cause";
4
+import * as Clock from "effect/Clock";
5
+import * as ConfigProvider from "effect/ConfigProvider";
6
+import * as Duration from "effect/Duration";
7
+import * as Effect from "effect/Effect";
8
+import * as Exit from "effect/Exit";
9
+import * as FileSystem from "effect/FileSystem";
10
+import * as Option from "effect/Option";
11
+import * as Path from "effect/Path";
12
+import * as Sink from "effect/Sink";
13
+import * as Stream from "effect/Stream";
14
+import { ChildProcess, ChildProcessSpawner } from "effect/process";
15
+
16
+import { signWithJsign } from "./windows-jsign.ts";
17
+
18
+const UNSIGNED = "MZ unsigned payload";
19
+const TRANSIENT_CHAIN =
20
+ "jsign: Unable to retrieve the certificate chain 'acct/profile'\nCaused by: java.io.IOException: InternalError - An internal error has occurred.\n";
21
+const TRANSIENT_SIGN =
22
+ "jsign: Couldn't sign t3.exe\nCaused by: java.security.GeneralSecurityException: java.io.IOException: InternalError - An internal error has occurred.\n";
23
+const BAD_SECRET =
24
+ "jsign: Unable to retrieve the certificate chain 'acct/profile'\nCaused by: java.io.IOException: AADSTS7000215: Invalid client secret provided.\n";
25
+
26
+/** What the stub does with the file jsign was given: sign it, or write junk and fail. */
27
+type Reply = { readonly exitCode: number; readonly stderr?: string; readonly write?: string };
28
+
29
+/** Stands in for jsign. Records the bytes it received and applies each reply in turn. */
30
+function stubJsign(replies: ReadonlyArray<Reply>) {
31
+ const inputs: Array<{ readonly path: string; readonly content: string }> = [];
32
+ const spawner = ChildProcessSpawner.make((command) =>
33
+ Effect.gen(function* () {
34
+ const fs = yield* FileSystem.FileSystem;
35
+ const args = ChildProcess.isStandardCommand(command) ? command.args.map(String) : [];
36
+ const target = args.at(-1)!;
37
+ inputs.push({ path: target, content: yield* fs.readFileString(target) });
38
+ const reply = replies[inputs.length - 1] ?? replies.at(-1)!;
39
+ if (reply.write !== undefined) yield* fs.writeFileString(target, reply.write);
40
+ return ChildProcessSpawner.makeHandle({
41
+ pid: ChildProcessSpawner.ProcessId(1),
42
+ exitCode: Effect.succeed(ChildProcessSpawner.ExitCode(reply.exitCode)),
43
+ isRunning: Effect.succeed(false),
44
+ kill: () => Effect.void,
45
+ unref: Effect.succeed(Effect.void),
46
+ stdin: Sink.drain,
47
+ stdout: Stream.empty,
48
+ stderr: reply.stderr ? Stream.make(new TextEncoder().encode(reply.stderr)) : Stream.empty,
49
+ all: Stream.empty,
50
+ getInputFd: () => Sink.drain,
51
+ getOutputFd: () => Stream.empty,
52
+ });
53
+ }).pipe(Effect.provide(NodeServices.layer), Effect.orDie),
54
+ );
55
+ return { inputs, spawner };
56
+}
57
+
58
+const signed = (content: string): Reply => ({ exitCode: 0, write: `${content}+signature` });
59
+
60
+const runSign = Effect.fn("test.runSign")(function* (replies: ReadonlyArray<Reply>) {
61
+ const fs = yield* FileSystem.FileSystem;
62
+ const path = yield* Path.Path;
63
+ const dir = yield* fs.makeTempDirectoryScoped({ prefix: "t3-jsign-" });
64
+ const file = path.join(dir, "t3.exe");
65
+ yield* fs.writeFileString(file, UNSIGNED);
66
+ const stub = stubJsign(replies);
67
+ const sleeps: Array<number> = [];
68
+ const clock = yield* Clock.Clock;
69
+ const exit = yield* signWithJsign(file).pipe(
70
+ Effect.provideService(ChildProcessSpawner.ChildProcessSpawner, stub.spawner),
71
+ // Records the backoff instead of waiting it out.
72
+ Effect.provideService(Clock.Clock, {
73
+ ...clock,
74
+ sleep: (duration) => Effect.sync(() => sleeps.push(Duration.toSeconds(duration))),
75
+ }),
76
+ Effect.provide(
77
+ ConfigProvider.layer(
78
+ ConfigProvider.fromEnv({
79
+ env: {
80
+ AZURE_TRUSTED_SIGNING_ENDPOINT: "https://eus.codesigning.azure.net/",
81
+ AZURE_TRUSTED_SIGNING_ACCOUNT_NAME: "acct",
82
+ AZURE_TRUSTED_SIGNING_CERTIFICATE_PROFILE_NAME: "profile",
83
+ },
84
+ }),
85
+ ),
86
+ ),
87
+ Effect.exit,
88
+ );
89
+ return {
90
+ ok: Exit.isSuccess(exit),
91
+ error: Exit.isFailure(exit)
92
+ ? Option.getOrUndefined(Cause.findErrorOption(exit.cause))
93
+ : undefined,
94
+ sleeps,
95
+ inputs: stub.inputs,
96
+ // jsign only ever sees a disposable copy, never the file itself.
97
+ signedInPlace: stub.inputs.some((input) => input.path === file),
98
+ content: yield* fs.readFileString(file),
99
+ // Only the original file is left: every attempt's copy is cleaned up.
100
+ entries: yield* fs.readDirectory(dir),
101
+ };
102
+});
103
+
104
+it.layer(NodeServices.layer)("signWithJsign", (it) => {
105
+ it.effect("retries transient Azure errors on a fresh copy and keeps only the signed file", () =>
106
+ Effect.gen(function* () {
107
+ const result = yield* runSign([
108
+ { exitCode: 1, stderr: TRANSIENT_CHAIN },
109
+ // A partial write must not reach the next attempt or the original.
110
+ { exitCode: 1, stderr: TRANSIENT_SIGN, write: "MZ half-written" },
111
+ signed(UNSIGNED),
112
+ ]);
113
+ assert.isTrue(result.ok);
114
+ assert.strictEqual(result.content, `${UNSIGNED}+signature`);
115
+ assert.deepStrictEqual(
116
+ result.inputs.map((input) => input.content),
117
+ [UNSIGNED, UNSIGNED, UNSIGNED],
118
+ );
119
+ assert.isFalse(result.signedInPlace);
120
+ assert.deepStrictEqual(result.sleeps, [5, 10]);
121
+ assert.deepStrictEqual(result.entries, ["t3.exe"]);
122
+ }),
123
+ );
124
+
125
+ it.effect("fails once without retrying on errors that are not transient", () =>
126
+ Effect.gen(function* () {
127
+ for (const reply of [
128
+ { exitCode: 1, stderr: BAD_SECRET },
129
+ { exitCode: 1, stderr: "jsign: Unsupported file: t3.exe\n", write: "MZ half-written" },
130
+ ]) {
131
+ const result = yield* runSign([reply, signed(UNSIGNED)]);
132
+ assert.strictEqual(result.error?._tag, "JsignFailedError");
133
+ assert.isFalse(result.error?._tag === "JsignFailedError" && result.error.transient);
134
+ assert.strictEqual(result.inputs.length, 1);
135
+ assert.deepStrictEqual(result.sleeps, []);
136
+ assert.strictEqual(result.content, UNSIGNED);
137
+ assert.deepStrictEqual(result.entries, ["t3.exe"]);
138
+ }
139
+ }),
140
+ );
141
+
142
+ it.effect("gives up after three retries and leaves the input unsigned", () =>
143
+ Effect.gen(function* () {
144
+ const result = yield* runSign([{ exitCode: 1, stderr: TRANSIENT_SIGN, write: "MZ junk" }]);
145
+ assert.isTrue(result.error?._tag === "JsignFailedError" && result.error.transient);
146
+ assert.strictEqual(result.inputs.length, 4);
147
+ assert.deepStrictEqual(result.sleeps, [5, 10, 20]);
148
+ assert.strictEqual(result.content, UNSIGNED);
149
+ assert.deepStrictEqual(result.entries, ["t3.exe"]);
150
+ }),
151
+ );
152
+});
scripts/lib/windows-jsign.ts
+87
-28
@@ -5,18 +5,54 @@
5
import * as NodeServices from "@effect/platform-node/NodeServices";
6
import * as Config from "effect/Config";
7
import * as Effect from "effect/Effect";
8
+import * as FileSystem from "effect/FileSystem";
9
+import * as Path from "effect/Path";
10
+import * as Schedule from "effect/Schedule";
11
import * as Schema from "effect/Schema";
12
+import * as Stream from "effect/Stream";
13
import { ChildProcess, ChildProcessSpawner } from "effect/process";
14
15
+// Upstream failures worth another attempt: Azure's `InternalError` (seen in
16
+// release runs on both the certificate chain and the sign call), HTTP 429/5xx,
17
+// and dropped connections. Credential, permission and input errors never match.
18
+const TRANSIENT_JSIGN_ERROR =
19
+ /\bInternalError - |HTTP Error (?:429|5\d\d)\b|java\.net\.(?:SocketTimeoutException|ConnectException)\b|Connection reset\b/;
20
+const JSIGN_RETRIES = 3;
21
+const STDERR_TAIL_CHARS = 64 * 1024;
22
+
23
export class JsignFailedError extends Schema.TaggedError<JsignFailedError>()("JsignFailedError", {
24
file: Schema.String,
25
exitCode: Schema.Number,
26
+ transient: Schema.Boolean,
27
}) {
28
override get message() {
16
- return `jsign exited with code ${String(this.exitCode)} signing ${this.file}.`;
29
+ return `jsign exited with code ${String(this.exitCode)} signing ${this.file}${this.transient ? " (transient Azure Trusted Signing error)" : ""}.`;
30
}
31
}
32
33
+/** Runs jsign, forwarding its stderr as it arrives and returning a tail of it for classification. */
34
+const runJsign = Effect.fn("runJsign")(function* (jsign: string, args: ReadonlyArray<string>) {
35
+ const spawner = yield* ChildProcessSpawner.ChildProcessSpawner;
36
+ const child = yield* spawner.spawn(
37
+ ChildProcess.make(jsign, args, { stdout: "inherit", stderr: "pipe" }),
38
+ );
39
+ const decoder = new TextDecoder();
40
+ let stderr = "";
41
+ const [exitCode] = yield* Effect.all(
42
+ [
43
+ child.exitCode.pipe(Effect.map(Number)),
44
+ Stream.runForEach(child.stderr, (chunk) =>
45
+ Effect.sync(() => {
46
+ process.stderr.write(chunk);
47
+ stderr = (stderr + decoder.decode(chunk, { stream: true })).slice(-STDERR_TAIL_CHARS);
48
+ }),
49
+ ),
50
+ ],
51
+ { concurrency: "unbounded" },
52
+ );
53
+ return { exitCode, stderr };
54
+});
55
+
56
export const signWithJsign = Effect.fn("signWithJsign")(function* (file: string) {
57
const { jsign, endpoint, account, profile } = yield* Config.all({
58
jsign: Config.String("T3CODE_JSIGN").pipe(Config.withDefault("jsign")),
@@ -24,34 +60,57 @@ export const signWithJsign = Effect.fn("signWithJsign")(function* (file: string)
60
account: Config.String("AZURE_TRUSTED_SIGNING_ACCOUNT_NAME"),
61
profile: Config.String("AZURE_TRUSTED_SIGNING_CERTIFICATE_PROFILE_NAME"),
62
});
27
- const spawner = yield* ChildProcessSpawner.ChildProcessSpawner;
28
- const child = yield* spawner.spawn(
29
- ChildProcess.make(
30
- jsign,
31
- [
32
- "--storetype",
33
- "TRUSTEDSIGNING",
34
- "--keystore",
35
- new URL(endpoint).host,
36
- "--alias",
37
- `${account}/${profile}`,
38
- "--alg",
39
- "SHA-256",
40
- "--tsaurl",
41
- "http://timestamp.acs.microsoft.com",
42
- "--tsmode",
43
- "RFC3161",
44
- // jsign appends a nested signature by default; signtool replaces.
45
- "--replace",
46
- file,
47
- ],
48
- { stdout: "inherit", stderr: "inherit" },
49
- ),
63
+ const fs = yield* FileSystem.FileSystem;
64
+ const path = yield* Path.Path;
65
+ const args = [
66
+ "--storetype",
67
+ "TRUSTEDSIGNING",
68
+ "--keystore",
69
+ new URL(endpoint).host,
70
+ "--alias",
71
+ `${account}/${profile}`,
72
+ "--alg",
73
+ "SHA-256",
74
+ "--tsaurl",
75
+ "http://timestamp.acs.microsoft.com",
76
+ "--tsmode",
77
+ "RFC3161",
78
+ // jsign appends a nested signature by default; signtool replaces.
79
+ "--replace",
80
+ ];
81
+
82
+ let attempt = 0;
83
+ // jsign rewrites its input in place, so each attempt signs a fresh copy and
84
+ // only a copy jsign finished with replaces the file (same directory, so the
85
+ // rename is atomic). A failed attempt never touches the original.
86
+ const signCopy = Effect.gen(function* () {
87
+ attempt++;
88
+ const dir = yield* fs.makeTempDirectoryScoped({
89
+ directory: path.dirname(file),
90
+ prefix: ".jsign-",
91
+ });
92
+ const copy = path.join(dir, path.basename(file));
93
+ yield* fs.copyFile(file, copy);
94
+ const { exitCode, stderr } = yield* runJsign(jsign, [...args, copy]);
95
+ if (exitCode !== 0) {
96
+ const transient = TRANSIENT_JSIGN_ERROR.test(stderr);
97
+ if (transient && attempt <= JSIGN_RETRIES) {
98
+ yield* Effect.logWarning(
99
+ `[jsign] Transient Azure Trusted Signing error signing ${file} (attempt ${String(attempt)} of ${String(JSIGN_RETRIES + 1)}); retrying.`,
100
+ );
101
+ }
102
+ return yield* new JsignFailedError({ file, exitCode, transient });
103
+ }
104
+ yield* fs.rename(copy, file);
105
+ }).pipe(Effect.scoped);
106
+
107
+ yield* signCopy.pipe(
108
+ Effect.retry({
109
+ schedule: Schedule.exponential("5 seconds"),
110
+ times: JSIGN_RETRIES,
111
+ while: (error) => error._tag === "JsignFailedError" && error.transient,
112
+ }),
113
);
51
- const exitCode = Number(yield* child.exitCode);
52
- if (exitCode !== 0) {
53
- return yield* new JsignFailedError({ file, exitCode });
54
- }
114
});
115
116
export default function sign(configuration: { readonly path: string }): Promise<void> {