From 8e7835c5d0c2033da20530dcf3190a61c045a097 Mon Sep 17 00:00:00 2001 From: Justin Carlson <40642470+justcarlson@users.noreply.github.com> Date: Sat, 21 Nov 2026 13:34:00 -0500 Subject: [PATCH 1/3] fix(server): renew expired Antigravity CLI tokens for usage limits --- .../Drivers/AntigravityDriver.test.ts | 158 +++++++++++- .../src/provider/Drivers/AntigravityDriver.ts | 142 +++++++--- .../provider/antigravityUsageLimits.test.ts | 244 ++++++++++++++++++ .../src/provider/antigravityUsageLimits.ts | 124 +++++++-- 4 files changed, 611 insertions(+), 57 deletions(-) diff --git a/apps/server/src/provider/Drivers/AntigravityDriver.test.ts b/apps/server/src/provider/Drivers/AntigravityDriver.test.ts index 3c0135f419c66..34c00e4f41192 100644 --- a/apps/server/src/provider/Drivers/AntigravityDriver.test.ts +++ b/apps/server/src/provider/Drivers/AntigravityDriver.test.ts @@ -9,16 +9,22 @@ import { ProviderSessionId, ThreadId, type AntigravitySettings, + type ServerProvider, } from "@t3tools/contracts"; import * as HostProcess from "@t3tools/shared/HostProcess"; +import * as DateTime from "effect/DateTime"; +import * as Deferred from "effect/Deferred"; import * as Effect from "effect/Effect"; +import * as Fiber from "effect/Fiber"; import * as FileSystem from "effect/FileSystem"; import * as Layer from "effect/Layer"; import * as Path from "effect/Path"; import * as Redacted from "effect/Redacted"; import * as Schema from "effect/Schema"; +import * as Stream from "effect/Stream"; +import * as TestClock from "effect/testing/TestClock"; import * as ChildProcessSpawner from "effect/process/ChildProcessSpawner"; -import { HttpClient } from "effect/http"; +import { HttpClient, HttpClientResponse } from "effect/http"; import * as BackgroundPolicy from "../../background/BackgroundPolicy.ts"; import * as ServerConfig from "../../config.ts"; @@ -66,6 +72,7 @@ const makeHarness = Effect.fn("makeAntigravityDriverHarness")(function* ( readonly enabled?: boolean; /** Extra instance variables, such as ones a parent T3 turn already exported. */ readonly environment?: ReadonlyArray<{ readonly name: string; readonly value: string }>; + readonly httpClient?: HttpClient.HttpClient; } = {}, ) { const fs = yield* FileSystem.FileSystem; @@ -93,6 +100,8 @@ const makeHarness = Effect.fn("makeAntigravityDriverHarness")(function* ( readonly newSessionErrorData?: unknown; readonly initialMode?: string; readonly agentVersion?: string; + /** Rewrites `antigravity-oauth-token` on launch to simulate `agy` renewing its access token. */ + readonly renewTokenExpiry?: string; } = {}, ) { const directory = path.join(root, name); @@ -100,10 +109,25 @@ const makeHarness = Effect.fn("makeAntigravityDriverHarness")(function* ( yield* fs.makeDirectory(directory, { recursive: true }); const authorizationUrl = "https://accounts.google.com/o/oauth2/v2/auth?response_type=code&redirect_uri=http%3A%2F%2F127.0.0.1%3A51234%2F&state=fixture-state"; + const renewedTokenJson = + options.renewTokenExpiry === undefined + ? undefined + : JSON.stringify({ + token: { + access_token: "renewed-access-token", + refresh_token: "refresh-a", + expiry: options.renewTokenExpiry, + }, + }); yield* fs.writeFileString( executablePath, [ "#!/bin/sh", + ...(renewedTokenJson === undefined + ? [] + : [ + `printf '%s' ${shellQuote(renewedTokenJson)} > "$GEMINI_HOME/antigravity-acp/antigravity-oauth-token"`, + ]), ...(options.loginRequired ? [`printf '%s\\n' ${shellQuote(ANTIGRAVITY_AUTH_STDOUT_PREFIX + authorizationUrl)}`] : []), @@ -221,7 +245,7 @@ const makeHarness = Effect.fn("makeAntigravityDriverHarness")(function* ( return handle; }), ); - const instance = yield* AntigravityDriver.create({ + const createdInstance = AntigravityDriver.create({ instanceId, displayName: "Google test account", enabled: options.enabled ?? true, @@ -242,6 +266,9 @@ const makeHarness = Effect.fn("makeAntigravityDriverHarness")(function* ( Effect.provide(layerInstallation), Effect.provideService(ChildProcessSpawner.ChildProcessSpawner, observedSpawner), ); + const instance = yield* options.httpClient + ? createdInstance.pipe(Effect.provideService(HttpClient.HttpClient, options.httpClient)) + : createdInstance; const refresh = instance.refreshModels; if (!refresh) return yield* Effect.die("Antigravity does not expose model refresh."); const readRequests = Effect.gen(function* () { @@ -703,4 +730,131 @@ it.layer(layerTest)("AntigravityDriver", (it) => { expect(yield* fs.exists(legacyRoot)).toBe(false); }), ); + + it.effect.skipIf(windowsHost)( + "renews an expired CLI token for limits via authenticate without opening a session or clearing auth on failure", + () => + Effect.gen(function* () { + yield* TestClock.setTime( + DateTime.toEpochMillis(DateTime.makeUnsafe("2026-11-21T12:00:00Z")), + ); + const authorizations: Array = []; + const http = HttpClient.make((request) => + Effect.sync(() => { + authorizations.push(request.headers.authorization); + return HttpClientResponse.fromWeb( + request, + request.url.endsWith("/userinfo") + ? Response.json({ id: "google-user-1" }) + : Response.json({ + buckets: [ + { + bucketId: "gemini-5h", + window: "5h", + remainingFraction: 0.75, + resetTime: "2099-01-01T05:00:00Z", + }, + ], + }), + ); + }), + ); + const h = yield* makeHarness({ + httpClient: http, + environment: [ + { name: "DISPLAY", value: ":0" }, + { name: "WAYLAND_DISPLAY", value: "wayland-1" }, + ], + }); + const nextSnapshot = (predicate: (snapshot: ServerProvider) => boolean) => + h.instance.snapshot.streamChanges.pipe( + Stream.filter(predicate), + Stream.runHead, + Effect.forkChild({ startImmediately: true }), + ); + const initialUsagePublish = yield* nextSnapshot( + (snapshot) => snapshot.usageLimits?.unavailable?.reason === "unsupported", + ); + yield* h.refresh(); + if ((yield* h.instance.snapshot.getSnapshot).usageLimits === undefined) { + yield* Fiber.join(initialUsagePublish); + } else { + yield* Fiber.interrupt(initialUsagePublish); + } + const beforeModels = (yield* h.instance.snapshot.getSnapshot).models; + const tokenPath = h.path.join( + h.profileDirectory, + "antigravity-acp", + "antigravity-oauth-token", + ); + const writeExpired = (refreshToken: string) => + h.fs.writeFileString( + tokenPath, + JSON.stringify({ + token: { + access_token: "expired-access-token", + refresh_token: refreshToken, + expiry: "2026-11-21T11:00:00Z", + }, + }), + ); + const requestsBefore = (yield* h.readRequests).length; + const launchesBefore = h.launches.length; + h.controls.selected = yield* h.makeExecutable("runtime renew", { + renewTokenExpiry: "2026-11-21T13:00:00Z", + }); + yield* writeExpired("refresh-a"); + + const nextUsagePublish = yield* nextSnapshot( + (snapshot) => + snapshot.usageLimits !== undefined && + snapshot.usageLimits.unavailable?.reason !== "unsupported", + ); + yield* h.instance.snapshot.refresh; + const afterRenewal = yield* Fiber.join(nextUsagePublish); + expect(afterRenewal._tag).toBe("Some"); + if (afterRenewal._tag === "Some") { + expect(afterRenewal.value.usageLimits?.unavailable).toBeUndefined(); + expect(afterRenewal.value.usageLimits?.windows).toEqual([ + expect.objectContaining({ id: "gemini-5h", usedPercent: 25 }), + ]); + } + expect(authorizations.length).toBeGreaterThan(0); + expect(authorizations.every((value) => value === "Bearer renewed-access-token")).toBe(true); + const renewalRequests = (yield* h.readRequests) + .slice(requestsBefore) + .map((request) => request.method); + expect(renewalRequests).toEqual(["initialize", "auth/login"]); + const renewalLaunch = h.launches + .slice(launchesBefore) + .find((launch) => launch.tempDirectory !== undefined); + expect(renewalLaunch?.environment.DISPLAY).toBeUndefined(); + expect(renewalLaunch?.environment.WAYLAND_DISPLAY).toBeUndefined(); + expect(renewalLaunch?.environment.SSH_CONNECTION).toBeTruthy(); + yield* h.assertClosed; + + // A failed background renewal must not clear models or flip auth to unauthenticated. + const failedRenewalStarted = yield* Deferred.make(); + const allowFailedRenewal = yield* Deferred.make(); + h.controls.selected = h.signedOut; + h.controls.beforeAcquire = Deferred.succeed(failedRenewalStarted, undefined).pipe( + Effect.andThen(Deferred.await(allowFailedRenewal)), + ); + yield* writeExpired("refresh-revoked"); + yield* TestClock.adjust("1 minute"); + const afterFailedRefresh = yield* nextSnapshot( + (snapshot) => snapshot.checkedAt === "2026-11-21T12:01:01.000Z", + ); + yield* h.instance.snapshot.refresh; + yield* Deferred.await(failedRenewalStarted); + yield* TestClock.adjust("1 second"); + yield* Deferred.succeed(allowFailedRenewal, undefined); + yield* Fiber.join(afterFailedRefresh); + expect(h.releases).toContain(h.signedOut.version); + yield* h.assertClosed; + const afterFailure = yield* h.instance.snapshot.getSnapshot; + expect(afterFailure.auth.status).toBe("authenticated"); + expect(afterFailure.models).toEqual(beforeModels); + }), + ); }); diff --git a/apps/server/src/provider/Drivers/AntigravityDriver.ts b/apps/server/src/provider/Drivers/AntigravityDriver.ts index 3d426785813c3..8c478a3ad2b60 100644 --- a/apps/server/src/provider/Drivers/AntigravityDriver.ts +++ b/apps/server/src/provider/Drivers/AntigravityDriver.ts @@ -207,6 +207,7 @@ export const AntigravityDriver: ProviderDriver< const prepareSpawn = Effect.fn("AntigravityDriver.prepareSpawn")(function* ( cwd: string, baseEnv: NodeJS.ProcessEnv, + options?: { readonly headless?: boolean }, ): Effect.fn.Return< { readonly executable: AntigravityInstallation.AntigravityExecutable; @@ -278,34 +279,42 @@ export const AntigravityDriver: ProviderDriver< ), ), ); - return { - executable, - spawn: buildAntigravityAcpSpawnInput({ - installation: executable, - profile, - cwd, - baseEnv, - auth, - runtimeTempDirectory, - }), - }; + const rawSpawn = buildAntigravityAcpSpawnInput({ + installation: executable, + profile, + cwd, + baseEnv, + auth, + runtimeTempDirectory, + }); + const spawn = + options?.headless && rawSpawn.env + ? (() => { + const { DISPLAY: _display, WAYLAND_DISPLAY: _wayland, ...env } = rawSpawn.env; + return { ...rawSpawn, env }; + })() + : rawSpawn; + return { executable, spawn }; }); const makeRuntime = Effect.fn("AntigravityDriver.makeRuntime")(function* ( - input: AntigravityAdapterV2RuntimeInput, + input: AntigravityAdapterV2RuntimeInput & { readonly headless?: boolean }, ): Effect.fn.Return< - AcpSessionRuntime.AcpSessionRuntime["Service"], + AcpSessionRuntime.AcpSessionRuntime["Service"] & { + readonly authenticate: (methodId: string) => Effect.Effect; + }, AcpErrors.AcpError | ProviderSetupError, Scope.Scope > { // `buildAntigravityAcpSpawnInput` sets `extendEnv: false`, so thread variables only reach the // agent's shell through `baseEnv`. - const { processEnvironment: threadEnvironment, ...runtimeInput } = input; + const { processEnvironment: threadEnvironment, headless, ...runtimeInput } = input; const { executable, spawn } = yield* prepareSpawn( runtimeInput.cwd, threadEnvironment === undefined ? processEnvironment : { ...processEnvironment, ...threadEnvironment }, + headless ? { headless } : undefined, ); const runtime = yield* makeAntigravityAcpRuntime({ ...runtimeInput, @@ -315,28 +324,48 @@ export const AntigravityDriver: ProviderDriver< spawn, }).pipe(Effect.provideService(SecureRandom.SecureRandom, random)); // A custom or PATH executable has no version until it answers initialize. - const startCompatible = Effect.fn("AntigravityDriver.startCompatible")(function* () { - const version = (yield* runtime.initialize()).agentInfo?.version; - const advisory = version ? yield* installation.compatibility(version) : undefined; - const refused = - version && - brokenRuntimeError({ - instanceId, - name: "Antigravity", - version, - advisory, - action: - executable.source === "managed" - ? "Update it in Antigravity setup" - : `Update the Antigravity executable at ${executable.executablePath}`, - }); - if (refused) { - return yield* new AcpErrors.AcpTransportError({ detail: refused.detail, cause: refused }); - } - return yield* runtime.start(); - }); + const initializeCompatible = Effect.fn("AntigravityDriver.initializeCompatible")( + function* () { + const initialized = yield* runtime.initialize(); + const version = initialized.agentInfo?.version; + const advisory = version ? yield* installation.compatibility(version) : undefined; + const refused = + version && + brokenRuntimeError({ + instanceId, + name: "Antigravity", + version, + advisory, + action: + executable.source === "managed" + ? "Update it in Antigravity setup" + : `Update the Antigravity executable at ${executable.executablePath}`, + }); + if (refused) { + return yield* new AcpErrors.AcpTransportError({ + detail: refused.detail, + cause: refused, + }); + } + return initialized; + }, + ); return { ...runtime, + // Evaluate authenticate lazily so ACP v1/v2 method selection runs after initialize. + authenticate: (methodId: string) => + initializeCompatible().pipe( + Effect.andThen(() => + runtime.authenticate + ? runtime.authenticate(methodId) + : Effect.fail( + new AcpErrors.AcpTransportError({ + detail: "Antigravity runtime does not support authentication.", + cause: undefined, + }), + ), + ), + ), setMode: (modeId: string) => runtime.getModeState.pipe( Effect.flatMap((modeState) => @@ -344,7 +373,8 @@ export const AntigravityDriver: ProviderDriver< ), ), start: () => - startCompatible().pipe( + initializeCompatible().pipe( + Effect.andThen(() => runtime.start()), Effect.tapError((cause): Effect.Effect => runtimeInput.onAuthorizationUrl === undefined && isAntigravitySignInRequiredError(cause) @@ -356,7 +386,9 @@ export const AntigravityDriver: ProviderDriver< }); const makeDisposableRuntime = Effect.fn("AntigravityDriver.makeDisposableRuntime")(function* ( - input: Pick, + input: Pick & { + readonly headless?: boolean; + }, ) { const cwd = yield* fileSystem .makeTempDirectoryScoped({ prefix: "t3-antigravity-setup-" }) @@ -385,6 +417,7 @@ export const AntigravityDriver: ProviderDriver< cwd, mcpServers: [], ...(input.onAuthorizationUrl ? { onAuthorizationUrl: input.onAuthorizationUrl } : {}), + ...(input.headless ? { headless: true } : {}), }); return { ...runtime, @@ -417,16 +450,15 @@ export const AntigravityDriver: ProviderDriver< }), ), ); - const { spawn } = yield* prepareSpawn(cwd, processEnvironment); + // Without a display it prints the link only, instead of opening a browser on this machine. + const { spawn } = yield* prepareSpawn(cwd, processEnvironment, { headless: true }); const failed = (detail: string, cause?: unknown) => new ProviderSetupError({ instanceId, operation: "start", detail, cause }); - // Without a display it prints the link only, instead of opening a browser on this machine. - const { DISPLAY: _display, WAYLAND_DISPLAY: _wayland, ...env } = spawn.env ?? {}; const child = yield* spawner .spawn( ChildProcess.make(spawn.command, [...spawn.args, "--login"], { cwd, - env, + env: spawn.env, extendEnv: false, shell: false, }), @@ -556,9 +588,39 @@ export const AntigravityDriver: ProviderDriver< }; }); + // Only Google account sign-in sets SSH_CONNECTION so a revoked token fails fast instead of opening a browser. + const renewCliToken = + auth.authMethod !== "oauth-personal" + ? undefined + : Effect.gen(function* () { + const processScope = yield* Scope.make(); + yield* Effect.addFinalizer((exit) => Scope.close(processScope, exit)); + return yield* authFlow + .withProcess( + Scope.close(processScope, Exit.void), + Effect.gen(function* () { + const runtime = yield* makeDisposableRuntime({ headless: true }); + yield* runtime.authenticate(auth.authMethod); + return "renewed" as const; + }), + ) + .pipe(Effect.provideService(Scope.Scope, processScope)); + }).pipe( + Effect.scoped, + Effect.withSpan("AntigravityDriver.renewCliToken"), + Effect.catch((cause) => + Effect.succeed( + isProviderSetupError(cause) && cause.operation === "startProcess" + ? ("busy" as const) + : ("failed" as const), + ), + ), + ); + const usage = yield* makeAntigravityUsageProbe({ profileDirectory, authMethod: auth.authMethod, + ...(renewCliToken ? { renewCliToken } : {}), }).pipe( Effect.provideService(FileSystem.FileSystem, fileSystem), Effect.provideService(Path.Path, path), diff --git a/apps/server/src/provider/antigravityUsageLimits.test.ts b/apps/server/src/provider/antigravityUsageLimits.test.ts index eec70e2e44fce..379ece05019fd 100644 --- a/apps/server/src/provider/antigravityUsageLimits.test.ts +++ b/apps/server/src/provider/antigravityUsageLimits.test.ts @@ -5,13 +5,16 @@ import * as Layer from "effect/Layer"; import { describe, expect, it } from "@effect/vitest"; import * as Context from "effect/Context"; import * as DateTime from "effect/DateTime"; +import * as Deferred from "effect/Deferred"; import * as Effect from "effect/Effect"; +import * as Fiber from "effect/Fiber"; import * as FileSystem from "effect/FileSystem"; import * as Path from "effect/Path"; import * as TestClock from "effect/testing/TestClock"; import { FetchHttpClient, HttpClient, HttpClientResponse } from "effect/http"; import { + type AntigravityCliTokenRenewalResult, decodeGoKeyringSecret, makeAntigravityUsageProbe, readWindowsCliCredential, @@ -74,6 +77,7 @@ const fixture = Effect.fn("AntigravityUsageTest.fixture")(function* ( keyringSecret?: string; /** Reads the OS keyring instead of `keyringSecret`. */ nativeKeyring?: boolean; + renewCliToken?: Effect.Effect; } = {}, ) { const fs = yield* FileSystem.FileSystem; @@ -141,6 +145,7 @@ const fixture = Effect.fn("AntigravityUsageTest.fixture")(function* ( profileDirectory, authMethod: options.authMethod ?? "oauth-personal", ...(options.nativeKeyring ? {} : { readKeyringSecret: Effect.succeed(options.keyringSecret) }), + ...(options.renewCliToken ? { renewCliToken: options.renewCliToken } : {}), }).pipe(Effect.provideService(HttpClient.HttpClient, http)); return { ...usage, requests, writeToken, tokenPath }; }); @@ -717,13 +722,19 @@ describe("Antigravity subscription limits", () => { expect(limits.windows).toHaveLength(4); expect(signedIn.requests.some((request) => request.url.endsWith("/token"))).toBe(false); + let businessRenewals = 0; const expired = yield* fixture({ authMethod: "oauth-business", missingToken: true, keyringSecret: keyringSecret("2026-10-09T12:00:30Z"), + renewCliToken: Effect.sync(() => { + businessRenewals++; + return "renewed" as const; + }), }); expect((yield* expired.probe).unavailable?.reason).toBe("probeFailed"); expect(expired.requests).toEqual([]); + expect(businessRenewals).toBe(0); }).pipe(Effect.scoped, Effect.provide(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer))), ); @@ -783,4 +794,237 @@ describe("Antigravity subscription limits", () => { } }).pipe(Effect.scoped, Effect.provide(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer))), ); + + it.effect( + "renews an expired personal CLI token and skips renewal when unsafe or impossible", + () => + Effect.gen(function* () { + yield* TestClock.setTime( + DateTime.toEpochMillis(DateTime.makeUnsafe("2026-10-09T12:00:00Z")), + ); + const fs = yield* FileSystem.FileSystem; + const path = yield* Path.Path; + let renewals = 0; + let cliTokenPath = ""; + const { probe, tokenPath } = yield* fixture({ + missingToken: true, + userId: "google-user-1", + renewCliToken: Effect.gen(function* () { + renewals++; + yield* fs + .writeFileString( + cliTokenPath, + JSON.stringify({ + token: { + access_token: "access-token", + refresh_token: "refresh-a", + expiry: "2026-10-09T13:00:00Z", + }, + }), + ) + .pipe(Effect.orDie); + return "renewed" as const; + }), + }); + cliTokenPath = path.join(path.dirname(tokenPath), "antigravity-oauth-token"); + yield* fs.writeFileString( + cliTokenPath, + JSON.stringify({ + token: { + access_token: "expired-token", + refresh_token: "refresh-a", + expiry: "2026-10-09T11:00:00Z", + }, + }), + ); + const limits = yield* probe; + expect(renewals).toBe(1); + expect(limits.unavailable).toBeUndefined(); + expect(limits.windows).toHaveLength(4); + + // Without a refresh token, do not invoke the CLI. + yield* fs.writeFileString( + cliTokenPath, + JSON.stringify({ + token: { + access_token: "expired-token", + refresh_token: " ", + expiry: "2026-10-09T11:00:00Z", + }, + }), + ); + expect((yield* probe).unavailable?.reason).toBe("probeFailed"); + expect(renewals).toBe(1); + }).pipe(Effect.scoped, Effect.provide(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer))), + ); + + it.effect( + "backs off failed and still-expired renewals exponentially, skips backoff when busy, and resets on change or clear", + () => + Effect.gen(function* () { + yield* TestClock.setTime( + DateTime.toEpochMillis(DateTime.makeUnsafe("2026-10-09T12:00:00Z")), + ); + const fs = yield* FileSystem.FileSystem; + const path = yield* Path.Path; + let nextOutcome: AntigravityCliTokenRenewalResult = "busy"; + let renewals = 0; + const { probe, clear, tokenPath } = yield* fixture({ + missingToken: true, + renewCliToken: Effect.sync(() => { + renewals++; + return nextOutcome; + }), + }); + const cliTokenPath = path.join(path.dirname(tokenPath), "antigravity-oauth-token"); + const writeExpired = (refreshToken: string) => + fs.writeFileString( + cliTokenPath, + JSON.stringify({ + token: { + access_token: "expired-token", + refresh_token: refreshToken, + expiry: "2026-10-09T11:00:00Z", + }, + }), + ); + yield* writeExpired("refresh-a"); + + // Busy (sign-in or sign-out in progress) must not back off. + expect((yield* probe).unavailable?.reason).toBe("probeFailed"); + expect((yield* probe).unavailable?.reason).toBe("probeFailed"); + expect(renewals).toBe(2); + + // Failures back off 1m -> 5m -> 15m -> 60m, then retry hourly so offline drops recover. + nextOutcome = "failed"; + expect((yield* probe).unavailable?.reason).toBe("probeFailed"); + expect((yield* probe).unavailable?.reason).toBe("probeFailed"); + expect(renewals).toBe(3); + + yield* TestClock.adjust("1 minute"); + expect((yield* probe).unavailable?.reason).toBe("probeFailed"); + expect(renewals).toBe(4); + yield* TestClock.adjust("4 minutes"); + expect((yield* probe).unavailable?.reason).toBe("probeFailed"); + expect(renewals).toBe(4); + yield* TestClock.adjust("1 minute"); + expect((yield* probe).unavailable?.reason).toBe("probeFailed"); + expect(renewals).toBe(5); + yield* TestClock.adjust("15 minutes"); + expect((yield* probe).unavailable?.reason).toBe("probeFailed"); + expect(renewals).toBe(6); + yield* TestClock.adjust("59 minutes"); + expect((yield* probe).unavailable?.reason).toBe("probeFailed"); + expect(renewals).toBe(6); + yield* TestClock.adjust("1 minute"); + expect((yield* probe).unavailable?.reason).toBe("probeFailed"); + expect(renewals).toBe(7); + + // A changed token file or explicit clear resets backoff immediately. + yield* writeExpired("refresh-b"); + expect((yield* probe).unavailable?.reason).toBe("probeFailed"); + expect(renewals).toBe(8); + yield* clear; + expect((yield* probe).unavailable?.reason).toBe("probeFailed"); + expect(renewals).toBe(9); + + // Rewriting a still-expired token still escalates backoff (1 minute, then 5 minutes). + let rewriteCount = 0; + let skewedTokenPath = ""; + const skewed = yield* fixture({ + missingToken: true, + renewCliToken: Effect.gen(function* () { + rewriteCount++; + yield* fs + .writeFileString( + skewedTokenPath, + JSON.stringify({ + token: { + access_token: `still-expired-${rewriteCount}`, + refresh_token: "refresh-skew", + expiry: "2026-10-09T11:30:00Z", + }, + }), + ) + .pipe(Effect.orDie); + return "renewed" as const; + }), + }); + skewedTokenPath = path.join(path.dirname(skewed.tokenPath), "antigravity-oauth-token"); + yield* fs.writeFileString( + skewedTokenPath, + JSON.stringify({ + token: { + access_token: "still-expired-0", + refresh_token: "refresh-skew", + expiry: "2026-10-09T11:30:00Z", + }, + }), + ); + expect((yield* skewed.probe).unavailable?.reason).toBe("probeFailed"); + expect(rewriteCount).toBe(1); + yield* TestClock.adjust("1 minute"); + expect((yield* skewed.probe).unavailable?.reason).toBe("probeFailed"); + expect(rewriteCount).toBe(2); + yield* TestClock.adjust("4 minutes"); + expect((yield* skewed.probe).unavailable?.reason).toBe("probeFailed"); + expect(rewriteCount).toBe(2); + yield* TestClock.adjust("1 minute"); + expect((yield* skewed.probe).unavailable?.reason).toBe("probeFailed"); + expect(rewriteCount).toBe(3); + }).pipe(Effect.scoped, Effect.provide(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer))), + ); + + it.effect("discards a renewal interrupted by clear and bounds hung renewals with a timeout", () => + Effect.gen(function* () { + yield* TestClock.setTime(DateTime.toEpochMillis(DateTime.makeUnsafe("2026-10-09T12:00:00Z"))); + const fs = yield* FileSystem.FileSystem; + const path = yield* Path.Path; + const started = yield* Deferred.make(); + const release = yield* Deferred.make(); + const hungStarted = yield* Deferred.make(); + let renewals = 0; + const { probe, clear, tokenPath } = yield* fixture({ + missingToken: true, + renewCliToken: Effect.gen(function* () { + renewals++; + if (renewals === 1) { + yield* Deferred.succeed(started, undefined); + return yield* Deferred.await(release); + } + yield* Deferred.succeed(hungStarted, undefined); + return yield* Effect.never; + }), + }); + const cliTokenPath = path.join(path.dirname(tokenPath), "antigravity-oauth-token"); + yield* fs.writeFileString( + cliTokenPath, + JSON.stringify({ + token: { + access_token: "expired-token", + refresh_token: "refresh-a", + expiry: "2026-10-09T11:00:00Z", + }, + }), + ); + + const first = yield* Effect.forkChild(probe); + yield* Deferred.await(started); + yield* clear; + yield* Deferred.succeed(release, "failed"); + expect((yield* Fiber.join(first)).unavailable?.reason).toBe("probeFailed"); + + // Because clear ran during renewal, no backoff was recorded; the next probe attempts renewal and times out at 30s. + const hung = yield* Effect.forkChild(probe); + yield* Deferred.await(hungStarted); + yield* TestClock.adjust("30 seconds"); + const timedOut = yield* Fiber.join(hung); + expect(timedOut.unavailable?.reason).toBe("probeFailed"); + expect(timedOut.unavailable?.message).toContain("saved sign-in has expired"); + expect(renewals).toBe(2); + // Timed-out renewal recorded backoff, so an immediate retry does not spawn again. + expect((yield* probe).unavailable?.reason).toBe("probeFailed"); + expect(renewals).toBe(2); + }).pipe(Effect.scoped, Effect.provide(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer))), + ); }); diff --git a/apps/server/src/provider/antigravityUsageLimits.ts b/apps/server/src/provider/antigravityUsageLimits.ts index fadf2207c31f2..1a09934abbb8e 100644 --- a/apps/server/src/provider/antigravityUsageLimits.ts +++ b/apps/server/src/provider/antigravityUsageLimits.ts @@ -34,6 +34,12 @@ const SUMMARY_WINDOW_MINS = new Map([ ["weekly", 7 * 24 * 60], ]); const MANUAL_REDIRECT: RequestInit = { redirect: "manual" }; +const CLI_RENEWAL_TIMEOUT = "30 seconds"; +const CLI_RENEWAL_BACKOFF_MS = [60_000, 5 * 60_000, 15 * 60_000, 60 * 60_000] as const; +const CLI_EXPIRED_MESSAGE = + "Antigravity's saved sign-in has expired. Start an Antigravity turn to renew it, then refresh limits."; + +export type AntigravityCliTokenRenewalResult = "renewed" | "busy" | "failed"; const TokenFile = Schema.Struct({ client_id: Schema.NonEmptyString, client_secret: Schema.NonEmptyString, @@ -41,7 +47,7 @@ const TokenFile = Schema.Struct({ project_id: Schema.optional(Schema.String), }); // The 1.5.x CLI never writes acp_token.json: it keeps its sign-in in the OS keyring, or in -// antigravity-oauth-token without one or when T3 bypasses the keyring. It stores no OAuth client, so T3 cannot refresh it. +// antigravity-oauth-token without one or when T3 bypasses the keyring. It stores no OAuth client, so T3 cannot refresh it directly. const CliToken = Schema.Struct({ token: Schema.Struct({ access_token: Schema.NonEmptyString, @@ -321,6 +327,7 @@ export const makeAntigravityUsageProbe = Effect.fn("makeAntigravityUsageProbe")( readonly profileDirectory: string; readonly authMethod: AntigravitySettings["authMethod"]; readonly readKeyringSecret?: Effect.Effect; + readonly renewCliToken?: Effect.Effect; }) { const fs = yield* FileSystem.FileSystem; const path = yield* Path.Path; @@ -338,8 +345,39 @@ export const makeAntigravityUsageProbe = Effect.fn("makeAntigravityUsageProbe")( let cached: | { fingerprint: string; account: string; accessToken: string; expiresAt: number } | undefined; + let renewalBackoff: + | { readonly storedHash: string; readonly failures: number; readonly retryAfter: number } + | undefined; let generation = 0; + const recordRenewalFailure = ( + startedGeneration: number, + storedHash: string, + at: number, + previousStoredHash = storedHash, + ) => { + if (generation !== startedGeneration) return; + const failures = + renewalBackoff !== undefined && + (renewalBackoff.storedHash === storedHash || renewalBackoff.storedHash === previousStoredHash) + ? renewalBackoff.failures + 1 + : 1; + const delay = + CLI_RENEWAL_BACKOFF_MS[Math.min(failures - 1, CLI_RENEWAL_BACKOFF_MS.length - 1)]!; + renewalBackoff = { + storedHash, + failures, + retryAfter: at + delay, + }; + }; + const readStoredCliToken = Effect.gen(function* () { + // Google account instances bypass the keyring, whose one entry every profile shares. + return (yield* fs.exists(cliTokenPath)) + ? yield* fs.readFileString(cliTokenPath) + : input.authMethod === "oauth-business" + ? yield* readKeyringSecret + : undefined; + }); const request = (request: HttpClientRequest.HttpClientRequest) => client.execute(request).pipe( Effect.provideService(FetchHttpClient.RequestInit, MANUAL_REDIRECT), @@ -359,12 +397,7 @@ export const makeAntigravityUsageProbe = Effect.fn("makeAntigravityUsageProbe")( let projectId: string | undefined; if (!(yield* fs.exists(tokenPath))) { cached = undefined; - // Google account instances bypass the keyring, whose one entry every profile shares. - const stored = (yield* fs.exists(cliTokenPath)) - ? yield* fs.readFileString(cliTokenPath) - : input.authMethod === "oauth-business" - ? yield* readKeyringSecret - : undefined; + const stored = yield* readStoredCliToken; if (stored === undefined) { return makeUnavailableUsageLimits({ checkedAt, @@ -372,14 +405,74 @@ export const makeAntigravityUsageProbe = Effect.fn("makeAntigravityUsageProbe")( message: "Sign in with Google to see Antigravity limits.", }); } - const { token } = yield* decodeCliToken(stored); + let { token } = yield* decodeCliToken(stored); if (!(Date.parse(token.expiry ?? "") > now + 60_000)) { - return makeUnavailableUsageLimits({ - checkedAt, - reason: "probeFailed", - message: - "Antigravity's saved sign-in has expired. Start an Antigravity turn to renew it, then refresh limits.", - }); + const storedHash = yield* sha256(stored); + const blocked = + renewalBackoff?.storedHash === storedHash && now < renewalBackoff.retryAfter; + const canRenew = + input.authMethod === "oauth-personal" && + input.renewCliToken !== undefined && + Boolean(token.refresh_token?.trim()) && + !blocked; + if (!canRenew) { + return makeUnavailableUsageLimits({ + checkedAt, + reason: "probeFailed", + message: CLI_EXPIRED_MESSAGE, + }); + } + const outcome = yield* input.renewCliToken.pipe( + Effect.timeoutOption(CLI_RENEWAL_TIMEOUT), + Effect.map((result) => Option.getOrElse(result, () => "failed" as const)), + ); + if (generation !== startedGeneration) { + return makeUnavailableUsageLimits({ + checkedAt, + reason: "probeFailed", + message: CLI_EXPIRED_MESSAGE, + }); + } + if (outcome !== "renewed") { + if (outcome !== "busy") { + recordRenewalFailure(startedGeneration, storedHash, yield* Clock.currentTimeMillis); + } + return makeUnavailableUsageLimits({ + checkedAt, + reason: "probeFailed", + message: CLI_EXPIRED_MESSAGE, + }); + } + const refreshedStored = yield* readStoredCliToken; + if (generation !== startedGeneration) { + return makeUnavailableUsageLimits({ + checkedAt, + reason: "probeFailed", + message: CLI_EXPIRED_MESSAGE, + }); + } + if (refreshedStored === undefined) { + return makeUnavailableUsageLimits({ + checkedAt, + reason: "unsupported", + message: "Sign in with Google to see Antigravity limits.", + }); + } + const refreshed = yield* decodeCliToken(refreshedStored); + const renewedAt = yield* Clock.currentTimeMillis; + if (!(Date.parse(refreshed.token.expiry ?? "") > renewedAt + 60_000)) { + const refreshedHash = yield* sha256(refreshedStored); + recordRenewalFailure(startedGeneration, refreshedHash, renewedAt, storedHash); + return makeUnavailableUsageLimits({ + checkedAt, + reason: "probeFailed", + message: CLI_EXPIRED_MESSAGE, + }); + } + if (generation === startedGeneration) renewalBackoff = undefined; + token = refreshed.token; + } else if (generation === startedGeneration) { + renewalBackoff = undefined; } accessToken = token.access_token; account = yield* request( @@ -484,7 +577,7 @@ export const makeAntigravityUsageProbe = Effect.fn("makeAntigravityUsageProbe")( }); const probe = read.pipe( Effect.provideService(Digest.Digest, crypto), - Effect.timeout("30 seconds"), + Effect.timeout("70 seconds"), Effect.catch(() => Effect.gen(function* () { return makeUnavailableUsageLimits({ @@ -499,6 +592,7 @@ export const makeAntigravityUsageProbe = Effect.fn("makeAntigravityUsageProbe")( probe, clear: Effect.sync(() => { cached = undefined; + renewalBackoff = undefined; generation++; }), }; From 388d4db51d99e2b65120fee6a922d9b829890bbf Mon Sep 17 00:00:00 2001 From: Julius Marminge Date: Sat, 21 Nov 2026 18:45:12 +0000 Subject: [PATCH 2/3] refactor(server): share the expired sign-in result in the Antigravity limits probe Co-Authored-By: Claude Opus 5.5 --- .../src/provider/Drivers/AntigravityDriver.ts | 2 +- .../src/provider/antigravityUsageLimits.ts | 38 ++++++------------- 2 files changed, 12 insertions(+), 28 deletions(-) diff --git a/apps/server/src/provider/Drivers/AntigravityDriver.ts b/apps/server/src/provider/Drivers/AntigravityDriver.ts index 8c478a3ad2b60..f0c956ca7e5cb 100644 --- a/apps/server/src/provider/Drivers/AntigravityDriver.ts +++ b/apps/server/src/provider/Drivers/AntigravityDriver.ts @@ -588,7 +588,7 @@ export const AntigravityDriver: ProviderDriver< }; }); - // Only Google account sign-in sets SSH_CONNECTION so a revoked token fails fast instead of opening a browser. + // Only Google account sign-in renews here: its spawn sets SSH_CONNECTION, so a revoked token fails fast instead of opening a browser. const renewCliToken = auth.authMethod !== "oauth-personal" ? undefined diff --git a/apps/server/src/provider/antigravityUsageLimits.ts b/apps/server/src/provider/antigravityUsageLimits.ts index 1a09934abbb8e..d22f2b1cbbe05 100644 --- a/apps/server/src/provider/antigravityUsageLimits.ts +++ b/apps/server/src/provider/antigravityUsageLimits.ts @@ -36,8 +36,6 @@ const SUMMARY_WINDOW_MINS = new Map([ const MANUAL_REDIRECT: RequestInit = { redirect: "manual" }; const CLI_RENEWAL_TIMEOUT = "30 seconds"; const CLI_RENEWAL_BACKOFF_MS = [60_000, 5 * 60_000, 15 * 60_000, 60 * 60_000] as const; -const CLI_EXPIRED_MESSAGE = - "Antigravity's saved sign-in has expired. Start an Antigravity turn to renew it, then refresh limits."; export type AntigravityCliTokenRenewalResult = "renewed" | "busy" | "failed"; const TokenFile = Schema.Struct({ @@ -407,6 +405,12 @@ export const makeAntigravityUsageProbe = Effect.fn("makeAntigravityUsageProbe")( } let { token } = yield* decodeCliToken(stored); if (!(Date.parse(token.expiry ?? "") > now + 60_000)) { + const expired = makeUnavailableUsageLimits({ + checkedAt, + reason: "probeFailed", + message: + "Antigravity's saved sign-in has expired. Start an Antigravity turn to renew it, then refresh limits.", + }); const storedHash = yield* sha256(stored); const blocked = renewalBackoff?.storedHash === storedHash && now < renewalBackoff.retryAfter; @@ -416,40 +420,24 @@ export const makeAntigravityUsageProbe = Effect.fn("makeAntigravityUsageProbe")( Boolean(token.refresh_token?.trim()) && !blocked; if (!canRenew) { - return makeUnavailableUsageLimits({ - checkedAt, - reason: "probeFailed", - message: CLI_EXPIRED_MESSAGE, - }); + return expired; } const outcome = yield* input.renewCliToken.pipe( Effect.timeoutOption(CLI_RENEWAL_TIMEOUT), Effect.map((result) => Option.getOrElse(result, () => "failed" as const)), ); if (generation !== startedGeneration) { - return makeUnavailableUsageLimits({ - checkedAt, - reason: "probeFailed", - message: CLI_EXPIRED_MESSAGE, - }); + return expired; } if (outcome !== "renewed") { if (outcome !== "busy") { recordRenewalFailure(startedGeneration, storedHash, yield* Clock.currentTimeMillis); } - return makeUnavailableUsageLimits({ - checkedAt, - reason: "probeFailed", - message: CLI_EXPIRED_MESSAGE, - }); + return expired; } const refreshedStored = yield* readStoredCliToken; if (generation !== startedGeneration) { - return makeUnavailableUsageLimits({ - checkedAt, - reason: "probeFailed", - message: CLI_EXPIRED_MESSAGE, - }); + return expired; } if (refreshedStored === undefined) { return makeUnavailableUsageLimits({ @@ -463,11 +451,7 @@ export const makeAntigravityUsageProbe = Effect.fn("makeAntigravityUsageProbe")( if (!(Date.parse(refreshed.token.expiry ?? "") > renewedAt + 60_000)) { const refreshedHash = yield* sha256(refreshedStored); recordRenewalFailure(startedGeneration, refreshedHash, renewedAt, storedHash); - return makeUnavailableUsageLimits({ - checkedAt, - reason: "probeFailed", - message: CLI_EXPIRED_MESSAGE, - }); + return expired; } if (generation === startedGeneration) renewalBackoff = undefined; token = refreshed.token; From e67226ad1c528e0ec06993333d332b446712d0a3 Mon Sep 17 00:00:00 2001 From: Julius Marminge Date: Sat, 21 Nov 2026 18:52:25 +0000 Subject: [PATCH 3/3] fix(server): give Antigravity token renewal a cold-launch budget A Windows launch can take about a minute before initialize, so match sign-in's 90s startup plus 30s authenticate bounds. Co-Authored-By: Claude Opus 5.5 --- apps/server/src/provider/AntigravityProvider.ts | 2 +- apps/server/src/provider/antigravityUsageLimits.test.ts | 4 ++-- apps/server/src/provider/antigravityUsageLimits.ts | 5 +++-- 3 files changed, 6 insertions(+), 5 deletions(-) diff --git a/apps/server/src/provider/AntigravityProvider.ts b/apps/server/src/provider/AntigravityProvider.ts index b3b68d46e8ba8..36ca1b9f5526f 100644 --- a/apps/server/src/provider/AntigravityProvider.ts +++ b/apps/server/src/provider/AntigravityProvider.ts @@ -250,7 +250,7 @@ export const makeAntigravityProvider = Effect.fn("makeAntigravityProvider")(func Effect.flatMap((state) => options.stampIdentity(state.draft)), ); - // The quota read can take 30 seconds, so it never blocks readiness or a session start. + // The quota read can take minutes while it renews a sign-in, so it never blocks readiness or a session start. // One read runs at a time; sign-in and sign-out interrupt it so a stale account never lands. const usageRead = yield* FiberHandle.make(); const republish = yield* Deferred.make>(); diff --git a/apps/server/src/provider/antigravityUsageLimits.test.ts b/apps/server/src/provider/antigravityUsageLimits.test.ts index 379ece05019fd..a93072565660f 100644 --- a/apps/server/src/provider/antigravityUsageLimits.test.ts +++ b/apps/server/src/provider/antigravityUsageLimits.test.ts @@ -1014,10 +1014,10 @@ describe("Antigravity subscription limits", () => { yield* Deferred.succeed(release, "failed"); expect((yield* Fiber.join(first)).unavailable?.reason).toBe("probeFailed"); - // Because clear ran during renewal, no backoff was recorded; the next probe attempts renewal and times out at 30s. + // Because clear ran during renewal, no backoff was recorded; the next probe attempts renewal and times out. const hung = yield* Effect.forkChild(probe); yield* Deferred.await(hungStarted); - yield* TestClock.adjust("30 seconds"); + yield* TestClock.adjust("2 minutes"); const timedOut = yield* Fiber.join(hung); expect(timedOut.unavailable?.reason).toBe("probeFailed"); expect(timedOut.unavailable?.message).toContain("saved sign-in has expired"); diff --git a/apps/server/src/provider/antigravityUsageLimits.ts b/apps/server/src/provider/antigravityUsageLimits.ts index d22f2b1cbbe05..88a9a669d213d 100644 --- a/apps/server/src/provider/antigravityUsageLimits.ts +++ b/apps/server/src/provider/antigravityUsageLimits.ts @@ -34,7 +34,8 @@ const SUMMARY_WINDOW_MINS = new Map([ ["weekly", 7 * 24 * 60], ]); const MANUAL_REDIRECT: RequestInit = { redirect: "manual" }; -const CLI_RENEWAL_TIMEOUT = "30 seconds"; +// Sign-in allows 90s for a cold launch (about a minute on Windows) plus 30s once initialized. +const CLI_RENEWAL_TIMEOUT = "2 minutes"; const CLI_RENEWAL_BACKOFF_MS = [60_000, 5 * 60_000, 15 * 60_000, 60 * 60_000] as const; export type AntigravityCliTokenRenewalResult = "renewed" | "busy" | "failed"; @@ -561,7 +562,7 @@ export const makeAntigravityUsageProbe = Effect.fn("makeAntigravityUsageProbe")( }); const probe = read.pipe( Effect.provideService(Digest.Digest, crypto), - Effect.timeout("70 seconds"), + Effect.timeout("160 seconds"), Effect.catch(() => Effect.gen(function* () { return makeUnavailableUsageLimits({