authorgravatar for 56691628+Mnigos@users.noreply.github.comIgor Makowski <56691628+Mnigos@users.noreply.github.com> 2026-10-06 06:07:29+02:00
committergravatar for noreply@github.comGitHub <noreply@github.com> 2026-10-05 21:07:29-07:00
log2103bfaa77c431e0923ceb53b52418c0eef174da
tree81f37210d8f0f46c1de492be169d35a66a7ff370
parent017c9a0eb53b2c100b5be2d366d2374038da9241
signature Signed by PGP key B5690EEEBB952194

fix(server): stop the startup project sync from delaying the app window (#14912)

2 files changed, 208 insertions(+), 0 deletions(-)

apps/server/src/serverRuntimeStartup.autoPull.test.ts created+201
...@@ -0,0 +1,201 @@
1import * as NodeCrypto from "@effect/platform-node/NodeCrypto";
2import { expect, it } from "@effect/vitest";
3import { DEFAULT_SERVER_SETTINGS, EnvironmentId, ProjectId } from "@t3tools/contracts";
4import { DEFAULT_SIGNAL_EXPORT } from "@t3tools/shared/observability";
5import * as OtelEnvironment from "@t3tools/shared/otelEnvironment";
6import * as Deferred from "effect/Deferred";
7import * as Effect from "effect/Effect";
8import * as Layer from "effect/Layer";
9import * as Path from "effect/Path";
10import { HttpServer } from "effect/unstable/http";
11import * as NetAddress from "effect/unstable/net/NetAddress";
12
13import * as EnvironmentAuth from "./auth/EnvironmentAuth.ts";
14import * as ServiceLauncherClient from "./cloud/serviceLauncherClient.ts";
15import * as ServerConfig from "./config.ts";
16import * as ServerEnvironment from "./environment/ServerEnvironment.ts";
17import * as Keybindings from "./keybindings.ts";
18import * as EffectWorker from "./orchestration-v2/EffectWorker.ts";
19import * as LegacyV1ThreadImporter from "./orchestration-v2/legacy/LegacyV1ThreadImporter.ts";
20import * as ProjectStore from "./orchestration-v2/ProjectStore.ts";
21import * as ProviderRuntimeRecovery from "./orchestration-v2/ProviderRuntimeRecoveryService.ts";
22import * as ProviderSessionManager from "./orchestration-v2/ProviderSessionManager.ts";
23import * as ThreadLaunch from "./orchestration-v2/ThreadLaunchService.ts";
24import * as ThreadManagement from "./orchestration-v2/ThreadManagementService.ts";
25import * as ExternalLauncher from "./process/externalLauncher.ts";
26import * as ProjectService from "./project/ProjectService.ts";
27import * as AgentAwarenessRelay from "./relay/AgentAwarenessRelay.ts";
28import { ServerActivation } from "./serverActivation.ts";
29import * as ServerLifecycleEvents from "./serverLifecycleEvents.ts";
30import * as ServerRuntimeStartup from "./serverRuntimeStartup.ts";
31import * as ServerSettings from "./serverSettings.ts";
32import * as AnalyticsService from "./telemetry/AnalyticsService.ts";
33import * as GitVcsDriver from "./vcs/GitVcsDriver.ts";
34
35it.effect("parks automatic pull until activation without delaying command readiness", () =>
36 Effect.scoped(
37 Effect.gen(function* () {
38 const activation = yield* Deferred.make<void>();
39 const prepared = yield* Deferred.make<void>();
40 const commitTrial = yield* Deferred.make<void>();
41 const statusCalled = yield* Deferred.make<string>();
42 const statusInterrupted = yield* Deferred.make<void>();
43 const cwd = "/auto-pull-project";
44 const updatedAt = "2026-01-01T00:00:00.000Z";
45 const snapshot = {
46 projects: [
47 {
48 id: ProjectId.make("auto-pull-project"),
49 title: "Auto pull project",
50 workspaceRoot: cwd,
51 repositoryIdentity: null,
52 defaultModelSelection: null,
53 scripts: [],
54 createdAt: updatedAt,
55 updatedAt,
56 deletedAt: null,
57 },
58 ],
59 updatedAt,
60 };
61 const recovery = {
62 terminalizedRuns: 0,
63 stoppedSessions: 0,
64 closedRequests: 0,
65 retiredEffects: 0,
66 requeuedEffects: 0,
67 };
68 const importSummary = { importedThreadCount: 0, importedMessageCount: 0 };
69 const dependencies: Layer.Layer<
70 Layer.Services<ReturnType<typeof ServerRuntimeStartup.layerWithOptions>>
71 > = Layer.mergeAll(
72 Layer.mock(ServerConfig.ServerConfig)({
73 ...(yield* ServerConfig.deriveServerPaths(cwd, undefined).pipe(
74 Effect.provide(Path.layer),
75 )),
76 baseDir: cwd,
77 logLevel: "Error",
78 traceMinLevel: "Info",
79 traceTimingEnabled: false,
80 traceBatchWindowMs: 200,
81 traceMaxBytes: 1024,
82 traceMaxFiles: 1,
83 otlpTracesUrl: undefined,
84 otlpMetricsUrl: undefined,
85 otlpLogsUrl: undefined,
86 otlpTracesExport: DEFAULT_SIGNAL_EXPORT,
87 otlpMetricsExport: DEFAULT_SIGNAL_EXPORT,
88 otlpLogsExport: DEFAULT_SIGNAL_EXPORT,
89 otelEnvironment: OtelEnvironment.none,
90 staticDir: undefined,
91 devAllowedOrigins: [],
92 desktopBootstrapToken: undefined,
93 logWebSocketEvents: false,
94 tailscaleServeEnabled: false,
95 tailscaleServePort: 443,
96 mode: "desktop",
97 cwd,
98 host: "localhost",
99 port: 3773,
100 devUrl: undefined,
101 noBrowser: true,
102 startupPresentation: "browser",
103 autoBootstrapProjectFromCwd: false,
104 }),
105 Layer.mock(Keybindings.Keybindings)({ start: Effect.void }),
106 Layer.mock(LegacyV1ThreadImporter.LegacyV1ThreadImporter)({
107 pendingThreadCount: Effect.succeed(0),
108 reconcileShells: Effect.succeed(importSummary),
109 importPendingTranscripts: Effect.succeed(importSummary),
110 }),
111 Layer.mock(ProviderRuntimeRecovery.ProviderRuntimeRecoveryService)({
112 recover: Effect.succeed(recovery),
113 prepareForShutdown: Effect.void,
114 reconcile: () => Effect.succeed(recovery),
115 }),
116 Layer.mock(ProviderSessionManager.ProviderSessionManagerV2)({ shutdown: Effect.void }),
117 Layer.mock(AgentAwarenessRelay.AgentAwarenessRelay)({ start: () => Effect.void }),
118 Layer.mock(EffectWorker.OrchestrationEffectWorkerV2)({ runOnce: Effect.never }),
119 Layer.mock(ServerLifecycleEvents.ServerLifecycleEvents)({
120 publish: (event) => Effect.succeed({ ...event, sequence: 1 }),
121 }),
122 Layer.mock(ServerSettings.ServerSettingsService)({
123 start: Effect.void,
124 getSettings: Effect.succeed({ ...DEFAULT_SERVER_SETTINGS, defaultAutoPull: true }),
125 }),
126 Layer.mock(ServerEnvironment.ServerEnvironment)({
127 getDescriptor: Effect.succeed({
128 environmentId: EnvironmentId.make("auto-pull-environment"),
129 label: "Test environment",
130 platform: { os: "darwin", arch: "arm64" },
131 serverVersion: "0.0.0-test",
132 capabilities: { repositoryIdentity: true },
133 }),
134 }),
135 Layer.mock(ProjectStore.ProjectStoreV2)({
136 listShells: () => Effect.succeed(snapshot.projects),
137 }),
138 Layer.mock(ProjectService.ProjectService)({ snapshot: Effect.succeed(snapshot) }),
139 Layer.mock(ThreadManagement.ThreadManagementService)({
140 getShellSnapshot: () =>
141 Effect.succeed({
142 schemaVersion: 1,
143 snapshotSequence: 0,
144 threads: [],
145 archivedThreads: [],
146 }),
147 }),
148 Layer.mock(ThreadLaunch.ThreadLaunchService)({}),
149 Layer.mock(ServiceLauncherClient.ServiceLauncherClient)({
150 managed: true,
151 prepareTrial: Deferred.succeed(prepared, undefined).pipe(
152 Effect.andThen(Deferred.await(commitTrial)),
153 Effect.as(undefined),
154 ),
155 }),
156 Layer.mock(GitVcsDriver.GitVcsDriver)({
157 statusDetails: (root) =>
158 Deferred.succeed(statusCalled, root).pipe(
159 Effect.andThen(Effect.never),
160 Effect.onInterrupt(() => Deferred.succeed(statusInterrupted, undefined)),
161 ),
162 }),
163 Layer.mock(AnalyticsService.AnalyticsService)({ record: () => Effect.void }),
164 NodeCrypto.layer,
165 Layer.mock(EnvironmentAuth.EnvironmentAuth)({}),
166 Layer.mock(ExternalLauncher.ExternalLauncher)({}),
167 Layer.mock(HttpServer.HttpServer)({
168 address: NetAddress.inetAddressFromIpStringUnsafe("127.0.0.1", 3773),
169 }),
170 Path.layer,
171 );
172
173 yield* Effect.gen(function* () {
174 const startup = yield* ServerRuntimeStartup.ServerRuntimeStartup;
175 yield* startup.markHttpListening;
176
177 // A reverted, awaited pull reaches statusDetails instead of prepareTrial.
178 // Race the two receipts so that regression fails without a timeout.
179 yield* Effect.raceFirst(Deferred.await(prepared), Deferred.await(statusCalled));
180 expect(yield* Deferred.isDone(activation)).toBe(false);
181 expect(yield* Deferred.isDone(statusCalled)).toBe(false);
182 expect(yield* Deferred.isDone(prepared)).toBe(true);
183
184 yield* Deferred.succeed(commitTrial, undefined);
185 yield* Deferred.await(activation);
186 expect(yield* Deferred.await(statusCalled)).toBe(cwd);
187 // statusDetails can never finish; readiness must not depend on it.
188 yield* startup.awaitCommandReady;
189 }).pipe(
190 Effect.provide(
191 ServerRuntimeStartup.layerWithOptions({
192 activate: Deferred.succeed(activation, undefined).pipe(Effect.asVoid),
193 awaitAuxiliaryParked: Effect.void,
194 }).pipe(Layer.provide(dependencies)),
195 ),
196 Effect.provideService(ServerActivation, Deferred.await(activation)),
197 );
198 expect(yield* Deferred.isDone(statusInterrupted)).toBe(true);
199 }),
200 ),
201);
apps/server/src/serverRuntimeStartup.ts+7
...@@ -537,6 +537,8 @@ const make = (options?: StartupOptions) =>...@@ -537,6 +537,8 @@ const make = (options?: StartupOptions) =>
537 ).pipe(Effect.map((targets): AutoBootstrapWelcomeTargets => targets)),537 ).pipe(Effect.map((targets): AutoBootstrapWelcomeTargets => targets)),
538 });538 });
539 yield* Effect.logInfo("V2 orchestration recovery completed", recovery);539 yield* Effect.logInfo("V2 orchestration recovery completed", recovery);
540 // Runs after activation: the status check fetches every enabled project's
541 // remote, and awaiting it here held command readiness for that long.
540 yield* runStartupPhase(542 yield* runStartupPhase(
541 "projects.auto-pull",543 "projects.auto-pull",
542 Effect.gen(function* () {544 Effect.gen(function* () {
...@@ -544,6 +546,11 @@ const make = (options?: StartupOptions) =>...@@ -544,6 +546,11 @@ const make = (options?: StartupOptions) =>
544 const settings = yield* serverSettings.getSettings;546 const settings = yield* serverSettings.getSettings;
545 yield* autoPullProjects(projects, settings);547 yield* autoPullProjects(projects, settings);
546 }),548 }),
549 ).pipe(
550 Effect.catch((cause) =>
551 Effect.logWarning("Failed to load projects for automatic pull", { cause }),
552 ),
553 forkParked,
547 );554 );
548555
549 const importPendingTranscripts = legacyV1ThreadImporter.importPendingTranscripts.pipe(556 const importPendingTranscripts = legacyV1ThreadImporter.importPendingTranscripts.pipe(