lael-labs/t3code

apps/server/src/cloud/selfUpdate.test.ts+34−0

@@ -20,6 +20,7 @@ interface HarnessOptions { · 19 unmodified lines
20	readonly managed?: boolean;	20	readonly managed?: boolean;
21	readonly preflight?: "ready" \| "blocked";	21	readonly preflight?: "ready" \| "blocked";
22	readonly automaticUpdateIdle?: (order: string[]) => Effect.Effect<void, ServerSelfUpdateError>;	22	readonly automaticUpdateIdle?: (order: string[]) => Effect.Effect<void, ServerSelfUpdateError>;
		23	readonly install?: (order: string[]) => Effect.Effect<void>;
23	readonly requestUpdate?: ServiceLauncherClient.ServiceLauncherClient["Service"]["requestUpdate"];	24	readonly requestUpdate?: ServiceLauncherClient.ServiceLauncherClient["Service"]["requestUpdate"];
24	}	25	}
25		26
@@ -35,6 +36,7 @@ const makeHarness = Effect.fn("test.make_self_update_harness")(function* ( · 9 unmodified lines
35	Effect.gen(function* () {	36	Effect.gen(function* () {
36	if (input.command === "npm") {	37	if (input.command === "npm") {
37	order.push("install");	38	order.push("install");
		39	yield* options.install?.(order) ?? Effect.void;
38	const prefix = input.args[input.args.indexOf("--prefix") + 1];	40	const prefix = input.args[input.args.indexOf("--prefix") + 1];
39	if (prefix === undefined) return yield* Effect.die("missing npm prefix");	41	if (prefix === undefined) return yield* Effect.die("missing npm prefix");
40	const entry = path.join(prefix, "node_modules", "t3", "dist", "bin.mjs");	42	const entry = path.join(prefix, "node_modules", "t3", "dist", "bin.mjs");
@@ -236,6 +238,38 @@ it.layer(NodeServices.layer)("server self update", (it) => { · 195 unmodified lines
236	}),	238	}),
237	);	239	);
238		240
		241	it.effect("allows automatic update staging to be interrupted before handoff", () =>
		242	Effect.gen(function* () {
		243	const installStarted = yield* Deferred.make<void>();
		244	const releaseInstall = yield* Deferred.make<void>();
		245	let installs = 0;
		246	const { selfUpdate, order } = yield* makeHarness({
		247	install: () => {
		248	installs += 1;
		249	return installs === 1
		250	? Deferred.succeed(installStarted, undefined).pipe(
		251	Effect.andThen(Deferred.await(releaseInstall)),
		252	)
		253	: Effect.void;
		254	},
		255	});
		256	const updateFiber = yield* selfUpdate
		257	.update({ targetVersion: "1.1.0", automatic: true })
		258	.pipe(Effect.forkChild);
		259	yield* Deferred.await(installStarted);
		260	const interruptFiber = yield* Fiber.interrupt(updateFiber).pipe(Effect.forkChild);
		261	yield* Deferred.succeed(releaseInstall, undefined);
		262	yield* Fiber.join(interruptFiber);
		263
		264	expect(order).toEqual(["install"]);
		265	expect(yield* selfUpdate.update({ targetVersion: "1.1.0", automatic: true })).toEqual({
		266	targetVersion: "1.1.0",
		267	method: "boot-service",
		268	updateId: "launcher-id",
		269	});
		270	}),
		271	);
		272
239	it.effect("blocks new commands after an automatic handoff is accepted", () =>	273	it.effect("blocks new commands after an automatic handoff is accepted", () =>
240	Effect.gen(function* () {	274	Effect.gen(function* () {
241	const { selfUpdate } = yield* makeHarness();	275	const { selfUpdate } = yield* makeHarness();

apps/server/src/cloud/selfUpdate.ts+20−18

 import { HostProcessExecutablePath } from "@t3tools/shared/hostProcess";
 import { hasAutomaticServerUpdateActiveWork } from "@t3tools/shared/automaticServerUpdate";
 import { compareSemverVersions } from "@t3tools/shared/semver";
+import * as Cause from "effect/Cause";
 import * as Context from "effect/Context";
 import * as Duration from "effect/Duration";
 import * as Effect from "effect/Effect";
             ? failWith(error.reason, error)
             : failWith(`Could not prepare t3@${targetVersion}.`, error),
         ),
+        Effect.interruptible,
       );
-      if (input.automatic === true) {
-        yield* commandAdmission.withPermits(1)(
-          Effect.gen(function* () {
-            yield* idleCheck.assertIdle.pipe(
-              Effect.tapError((error) =>
-                Effect.sync(() => {
-                  retryWhenIdleFailure = error.retryWhenIdle === true;
-                }),
-              ),
-            );
-            yield* Ref.set(automaticHandoffPending, true);
-          }),
-        );
-      }
       const activatePreparedUpdate = Effect.gen(function* () {
         yield* reportProgress("installing");
         const updateId = yield* launcher
         });
         return { targetVersion, method: "boot-service" as const, updateId };
       });
-      return yield* activatePreparedUpdate;
+      if (input.automatic !== true) return yield* activatePreparedUpdate;
+      return yield* commandAdmission
+        .withPermits(1)(
+          Effect.gen(function* () {
+            yield* idleCheck.assertIdle.pipe(
+              Effect.tapError((error) =>
+                Effect.sync(() => {
+                  retryWhenIdleFailure = error.retryWhenIdle === true;
+                }),
+              ),
+            );
+            yield* Ref.set(automaticHandoffPending, true);
+          }),
+        )
+        .pipe(Effect.andThen(activatePreparedUpdate));
     }).pipe(
-      Effect.onError(() =>
+      Effect.onError((cause) =>
         Effect.all(
           [
             Ref.set(inFlight, false),
             Ref.set(automaticHandoffPending, false),
             Ref.set(
               lastFailedTarget,
-              retryWhenIdleFailure
+              retryWhenIdleFailure || Cause.hasInterruptsOnly(cause)
                 ? previousFailedTarget
                 : input.automatic === true ||
                     previousFailedTarget === null ||

apps/server/src/orchestration/http.ts+15−5

         Effect.fn("environment.orchestration.dispatch")(function* (args) {
           yield* annotateEnvironmentRequest(args.endpoint.name);
           yield* requireEnvironmentScope(AuthOrchestrationOperateScope);
-          const normalizedCommand = yield* normalizeDispatchCommand(args.payload).pipe(
-            Effect.catch(() => failEnvironmentInvalidRequest("invalid_command")),
-          );
           return yield* serverSelfUpdate
-            .withCommandAdmission(orchestrationEngine.dispatch(normalizedCommand))
+            .withCommandAdmission(
+              Effect.gen(function* () {
+                const normalizedCommand = yield* normalizeDispatchCommand(args.payload).pipe(
+                  Effect.catch(() => failEnvironmentInvalidRequest("invalid_command")),
+                );
+                return yield* orchestrationEngine
+                  .dispatch(normalizedCommand)
+                  .pipe(
+                    Effect.catch((cause) =>
+                      failEnvironmentInternal("orchestration_dispatch_failed", cause),
+                    ),
+                  );
+              }),
+            )
             .pipe(
-              Effect.catch((cause) =>
+              Effect.catchTag("ServerSelfUpdateError", (cause) =>
                 failEnvironmentInternal("orchestration_dispatch_failed", cause),
               ),
             );

apps/web/src/components/ChatView.tsx+6−2

     if (
       serverUpdateEnvironmentId &&
       !reconnectingThroughVersionSkew &&
-      (serverUpdateState.status !== "idle" ||
+      (serverUpdateState.status === "running" ||
-        (showVersionMismatchBanner && versionMismatch && versionMismatchDismissKey))
+        serverUpdateState.status === "failed" ||
+        (showVersionMismatchBanner &&
+          (serverUpdateState.status === "pending" ||
+            (versionMismatch && versionMismatchDismissKey))))
     ) {
       const updateInProgress = serverUpdateState.status === "running";
       const updatePending = serverUpdateState.status === "pending";
         // slot would only repeat it.
         actions:
           updateInProgress ||
+          updatePending ||
           !versionMismatch ||
           versionMismatchSelfUpdate === "desktop-managed" ? undefined : (
             <ServerUpdateAction

apps/web/src/components/settings/ConnectionsSettings.tsx+5−2

   if (compact) {
     return (
-      <div className="flex items-center gap-2 pt-1 text-xs text-muted-foreground">
+      <label
+        className="flex w-fit cursor-pointer items-center gap-2 pt-1 text-xs text-muted-foreground"
+        onClick={(event) => event.stopPropagation()}
+      >
         {controlWithExplanation}
         <span>Auto-update when idle</span>
-      </div>
+      </label>
     );
   }

fix: harden automatic update transitions

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code