@toddzheng024/dscode-desktop 0.7.42 → 0.7.44

package/plugins/antigravity/adapter.mjs

@@ -0,0 +1,79 @@
+import { LlmAdapter, LlmError, ReasoningEffortId } from '@deepseek-ai/dsh-llm';
+import { isAttachmentError } from '@deepseek-ai/dsh-attachment';
+import { prepareImages } from '../custom/images.mjs';
+import { sseData } from '../providers/chat-stream.mjs';
+import { headers, responseError } from './client.mjs';
+import { modelRoute } from './models.mjs';
+import { requestBody, translate } from './wire.mjs';
+
+/** Cancelling one caller must not cancel a shared token refresh/catalog read. */
+async function abortable(promise, signal) {
+  signal.throwIfAborted();
+  let abort;
+  try {
+    return await Promise.race([promise, new Promise((_, reject) => {
+      abort = () => reject(signal.reason); signal.addEventListener('abort', abort, { once: true });
+    })]);
+  } finally { signal.removeEventListener('abort', abort); }
+}
+
+export class AntigravityAdapter extends LlmAdapter {
+  constructor(config) { super(); this.config = config; }
+  providerInfo(provider) { return { id: provider, name: 'Antigravity' }; }
+  providerRetryPolicy() { return this.config.options().retryPolicy; }
+  async listModels(provider) {
+    return (await this.config.models.list()).map(m => ({ provider, id: m.id, name: m.name, inputModalities: m.inputModalities ?? ['text', 'image'] }));
+  }
+  async resolveModel(provider, id) {
+    const m = await this.config.models.get(id);
+    const efforts = Object.keys(m.routes).filter(e => e !== 'default');
+    return { provider, id, name: m.name, inputModalities: m.inputModalities ?? ['text', 'image'], context: { contextWindow: m.contextWindow }, defaultMaxTokens: m.maxTokens,
+      ...(efforts.length ? { reasoning: { efforts: efforts.map(id => ({ id: ReasoningEffortId(id), name: id })), defaultEffort: ReasoningEffortId(efforts.includes('low') ? 'low' : efforts[0]) } } : {}) };
+  }
+  async *stream(options) {
+    const { session, models, client } = this.config;
+    const config = this.config.options();
+    const controller = new AbortController();
+    const signal = AbortSignal.any([controller.signal, ...(options.signal ? [options.signal] : [])]);
+    let timer, timedOut = false;
+    const pulse = ms => {
+      clearTimeout(timer);
+      timer = setTimeout(() => { timedOut = true; controller.abort(); }, ms);
+      timer.unref?.();
+    };
+    try {
+      signal.throwIfAborted();
+      const grant = await abortable(session.auth(), signal);
+      const model = await abortable(models.get(options.model), signal), route = modelRoute(model, options.reasoningEffort);
+      const attachments = this.config.resolveAttachments?.();
+      const images = await prepareImages(options.messages, { ...model, inputModalities: model.inputModalities ?? ['text', 'image'] }, attachments,
+        ref => attachments && this.config.resolveImageAccess?.(attachments, ref), signal);
+      signal.throwIfAborted();
+      const body = JSON.stringify(requestBody({ ...options, messages: images.messages }, model, route, grant.projectId, images));
+      let response;
+      pulse(config.headerTimeoutMs);
+      for (const endpoint of client.endpoints) {
+        response = await client.fetch(`${endpoint}/v1internal:streamGenerateContent?alt=sse`, {
+          method: 'POST', redirect: 'error', headers: { ...headers(grant.access), accept: 'text/event-stream' }, body, signal,
+        });
+        if (response.ok) break;
+        const error = await responseError(response);
+        // Only a missing endpoint is retried here; rate limits and transient
+        // failures belong to the Harness retry policy, never nested loops.
+        if (response.status !== 404 || endpoint === client.endpoints.at(-1)) throw error;
+      }
+      if (!response?.body || !response.headers.get('content-type')?.includes('text/event-stream')) throw new LlmError('Antigravity did not return a stream', 'MALFORMED_RESPONSE');
+      pulse(config.streamIdleTimeoutMs);
+      for await (const chunk of translate(sseData(response.body, () => pulse(config.streamIdleTimeoutMs)), { model: model.id, runtimeModel: route.id })) {
+        signal.throwIfAborted();
+        clearTimeout(timer); yield chunk; pulse(config.streamIdleTimeoutMs);
+      }
+    } catch (error) {
+      if (options.signal?.aborted) throw new LlmError('Antigravity request cancelled', 'ABORTED');
+      if (timedOut) throw new LlmError('Antigravity connection timed out; retry the request', 'TIMEOUT');
+      if (isAttachmentError(error)) throw new LlmError(`Antigravity image input failed: ${error.code}`, error.code);
+      if (error instanceof LlmError) throw error;
+      throw new LlmError('Could not complete the Antigravity request', 'TRANSPORT');
+    } finally { clearTimeout(timer); controller.abort(); }
+  }
+}

package/plugins/antigravity/client.mjs

@@ -0,0 +1,73 @@
+import { LlmError } from '@deepseek-ai/dsh-llm';
+import { errorCode, retryAfterMs } from '../providers/http-errors.mjs';
+
+// Wire compatibility follows pi-antigravity d59d22b (see NOTICE). This is an
+// unofficial model transport, independent of both the ACP agent and the CLI.
+export const ENDPOINTS = Object.freeze([
+  'https://daily-cloudcode-pa.googleapis.com',
+  'https://daily-cloudcode-pa.sandbox.googleapis.com',
+  'https://cloudcode-pa.googleapis.com',
+]);
+export const USER_AGENT = 'antigravity/cli/1.2.4 (aidev_client; os_type=linux; arch=amd64; cl=982146307; auth_method=consumer)';
+export const headers = token => ({ authorization: `Bearer ${token}`, 'content-type': 'application/json', 'User-Agent': USER_AGENT });
+
+export function projectId(data) {
+  if (!data || typeof data !== 'object') return undefined;
+  for (const key of ['antigravityProjectId', 'projectId', 'backendProjectId', 'userDefinedCloudaicompanionProject', 'cloudaicompanionProject', 'project']) {
+    const value = data[key], id = typeof value === 'string' ? value : value?.id;
+    if (typeof id === 'string' && id.trim()) return id;
+  }
+  for (const key of ['projects', 'projectIds', 'cloudaicompanionProjects']) {
+    for (const item of Array.isArray(data[key]) ? data[key] : []) {
+      const id = typeof item === 'string' ? item : projectId(item);
+      if (id) return id;
+    }
+  }
+  return undefined;
+}
+
+/** Never put server text, URLs containing auth codes, or fetch causes into logs. */
+export async function responseError(response) {
+  let error;
+  try { error = (await response.json())?.error; } catch { /* status is sufficient */ }
+  const code = errorCode(response.status, typeof error === 'object' ? error : undefined);
+  const delay = retryAfterMs(response.headers.get('retry-after'));
+  return new LlmError(`Antigravity request failed (HTTP ${response.status})`, code,
+    { status: response.status, ...(delay === undefined ? {} : { providerRetryAfterMs: delay }) });
+}
+
+export class AntigravityClient {
+  constructor({ fetch = globalThis.fetch, endpoints = ENDPOINTS, metadataTimeoutMs = 10000 } = {}) {
+    this.fetch = fetch; this.endpoints = endpoints; this.metadataTimeoutMs = metadataTimeoutMs;
+  }
+  async json(method, token, body, signal) {
+    const deadline = AbortSignal.timeout(this.metadataTimeoutMs);
+    const combined = AbortSignal.any([deadline, ...(signal ? [signal] : [])]);
+    let last;
+    for (const endpoint of this.endpoints) {
+      try {
+        const response = await this.fetch(`${endpoint}/v1internal:${method}`, {
+          method: 'POST', redirect: 'error', headers: headers(token), body: JSON.stringify(body), signal: combined,
+        });
+        if (response.ok) return await response.json();
+        last = await responseError(response);
+        // A quota/auth rejection is final; changing endpoints must not hide it.
+        if (![404, 500, 502, 503, 504].includes(response.status)) throw last;
+      } catch (error) {
+        if (signal?.aborted) throw new LlmError('Antigravity request cancelled', 'ABORTED');
+        if (deadline.aborted) throw new LlmError('Antigravity discovery timed out', 'TIMEOUT');
+        if (error instanceof LlmError) throw error;
+        last = new LlmError('Could not connect to Antigravity', 'TRANSPORT');
+      }
+    }
+    throw last ?? new LlmError('No Antigravity endpoint available', 'TRANSPORT');
+  }
+  async project(token, signal) {
+    const data = await this.json('loadCodeAssist', token, { metadata: { ideType: 'ANTIGRAVITY' } }, signal);
+    let id = projectId(data);
+    if (!id) id = projectId(await this.json('listCloudAICompanionProjects', token, {}, signal));
+    if (typeof id !== 'string' || !id) throw new LlmError('Antigravity did not return an enabled project for this account; open Antigravity to finish account setup, then sign in again', 'AUTH');
+    return id;
+  }
+  models(grant, signal) { return this.json('fetchAvailableModels', grant.access, { project: grant.projectId }, signal); }
+}

package/plugins/antigravity/command.mjs

@@ -0,0 +1,79 @@
+import { openBrowser } from '../account/index.mjs';
+import { authorize, callbackServer, exchangeCode } from './oauth.mjs';
+
+const message = (locale, en, zh) => locale.startsWith('zh') ? zh : en;
+
+export class AntigravityLogin {
+  constructor({ session, client, models, open = openBrowser, callback = callbackServer, exchange = exchangeCode }) {
+    Object.assign(this, { session, client, models, open, callback, exchange });
+  }
+  async status(locale) {
+    const grant = await this.session.current();
+    return [this.attempt ? message(locale, 'Waiting for Google sign-in in your browser. /antigravity cancel stops it.', '等待浏览器中的 Google 登录。/antigravity cancel 可取消。') : this.outcome,
+      grant ? message(locale, 'Antigravity is signed in. Use /provider antigravity. Tokens refresh automatically.', 'Antigravity 已登录。使用 /provider antigravity 切换；凭据会自动续期。')
+        : message(locale, 'Antigravity is not signed in. Run /antigravity login.', 'Antigravity 未登录。运行 /antigravity login。')].filter(Boolean).join('\n');
+  }
+  async login(locale) {
+    if (this.attempt) return this.status(locale);
+    const attempt = { ...authorize(), controller: new AbortController(), revision: this.session.revision };
+    this.attempt = attempt; this.outcome = undefined;
+    try {
+      attempt.listener = await this.callback(attempt.state, { signal: attempt.controller.signal });
+      if (this.attempt !== attempt) { attempt.listener.close(); return this.status(locale); }
+      attempt.done = this.follow(attempt, locale);
+      await this.open(attempt.url).catch(() => false);
+      return message(locale,
+        'Complete Google sign-in for Antigravity (community integration). Waiting for up to 5 minutes; /antigravity shows the result. If the browser did not open:',
+        '请在浏览器中完成 Antigravity 的 Google 登录（社区接入）。最多等待 5 分钟；/antigravity 查看结果。如果浏览器未打开，请访问：') + '\n' + attempt.url;
+    } catch {
+      if (this.attempt === attempt) this.attempt = undefined;
+      throw new Error(message(locale, 'Could not open the Antigravity login callback on port 51121. Close another pending login and retry.', '无法在 51121 端口启动登录回调。请关闭其他正在等待的登录后重试。'));
+    }
+  }
+  async follow(attempt, locale) {
+    try {
+      const code = await attempt.listener.code;
+      const grant = await this.exchange(code, attempt.verifier, this.client, { fetch: this.client.fetch, signal: attempt.controller.signal });
+      if (this.attempt !== attempt || attempt.controller.signal.aborted) return;
+      if (await this.session.save(grant, attempt.revision)) {
+        this.models.clear();
+        this.outcome = message(locale, 'Google sign-in completed. Use /provider antigravity.', 'Google 登录完成。使用 /provider antigravity。');
+      }
+    } catch {
+      if (this.attempt === attempt) this.outcome = message(locale, 'Antigravity sign-in did not complete. Check account setup and retry /antigravity login.', 'Antigravity 登录未完成。请检查账号设置后重试 /antigravity login。');
+    } finally {
+      attempt.listener.close();
+      if (this.attempt === attempt) this.attempt = undefined;
+    }
+  }
+  cancel(locale) {
+    this.session.revision++;
+    this.attempt?.controller.abort(); this.attempt?.listener?.close(); this.attempt = undefined;
+    return this.outcome = message(locale, 'Antigravity sign-in cancelled.', '已取消 Antigravity 登录。');
+  }
+  async logout(locale) {
+    this.cancel(locale); await this.session.logout(); this.models.clear(); this.outcome = undefined;
+    return message(locale, 'Removed the DSCODE Antigravity login. Other applications are unchanged.', '已移除 DSCODE 的 Antigravity 登录，其他应用的登录不变。');
+  }
+  dispose() { this.cancel('en'); }
+}
+
+export function antigravityCommand(login, language) {
+  return { name: 'antigravity', description: 'Antigravity Google login and Gemini models', input: { hint: '[login|status|models|cancel|logout]' },
+    handler: async ({ rawInput }) => {
+      const locale = language(), arg = String(rawInput ?? '').trim().toLowerCase();
+      try {
+        let text;
+        if (!arg || arg === 'status') text = await login.status(locale);
+        else if (arg === 'login') text = await login.login(locale);
+        else if (arg === 'cancel') text = login.cancel(locale);
+        else if (arg === 'logout') text = await login.logout(locale);
+        else if (arg === 'models') {
+          const models = await login.models.list(true);
+          text = [login.models.discovered ? 'Antigravity account model catalog' : 'Antigravity fallback catalog (availability not verified)', login.models.error,
+            ...models.map(m => `${m.id} · ${Object.keys(m.routes).join('/')} · ${m.contextWindow} context`)].filter(Boolean).join('\n');
+        } else return { kind: 'error', text: 'Usage: /antigravity [login|status|models|cancel|logout]' };
+        return { kind: 'success', text };
+      } catch { return { kind: 'error', text: message(locale, 'Antigravity operation failed. Check port 51121 and account connectivity, then retry.', 'Antigravity 操作失败。请检查 51121 端口和账号连接后重试。') }; }
+    } };
+}

package/plugins/antigravity/index.mjs

@@ -0,0 +1,49 @@
+import { registerStartupCommand } from '../providers/startup-commands.mjs';
+import z from '@deepseek-ai/schemastery';
+import { RetryPolicySchema, resolveRetryPolicy, resolveImageAttachmentAccess } from '@deepseek-ai/dsh-llm';
+import { plainConfig } from '../cordis-config/plain.mjs';
+import { readLanguage } from '../i18n/messages.mjs';
+import { AntigravityClient } from './client.mjs';
+import { AntigravitySession, GRANT_REF } from './oauth.mjs';
+import { AntigravityModels, PROVIDER } from './models.mjs';
+import { AntigravityAdapter } from './adapter.mjs';
+import { AntigravityLogin, antigravityCommand } from './command.mjs';
+
+export const name = 'dscode-antigravity';
+export const inject = ['llm', 'credentials'];
+export const Config = z.object({
+  apiKeyEnv: z.union([GRANT_REF]).role('credential-ref').default(GRANT_REF).volatile(),
+  headerTimeoutMs: z.number().min(1).default(30000).volatile(),
+  streamIdleTimeoutMs: z.number().min(1).default(120000).volatile(),
+  retryPolicy: RetryPolicySchema.volatile(),
+});
+export function resolveOptions(config = {}) {
+  const headerTimeoutMs = config.headerTimeoutMs ?? 30000, streamIdleTimeoutMs = config.streamIdleTimeoutMs ?? 120000;
+  if (![headerTimeoutMs, streamIdleTimeoutMs].every(n => Number.isFinite(n) && n > 0)) throw new Error('Antigravity timeouts must be positive');
+  return { headerTimeoutMs, streamIdleTimeoutMs, retryPolicy: resolveRetryPolicy(config.retryPolicy, name) };
+}
+export function apply(ctx, config = {}) {
+  ctx.inject(['settings'], scoped => scoped.effect(() => scoped.settings.configure({ auto: false }, ctx.fiber)));
+  const session = new AntigravitySession({
+    read: async () => (await ctx.credentials.resolve(GRANT_REF))?.value,
+    write: value => ctx.credentials.set(GRANT_REF, value), remove: () => ctx.credentials.unset(GRANT_REF),
+  });
+  const client = new AntigravityClient(), models = new AntigravityModels(session, client);
+  let last = resolveOptions(plainConfig(config));
+  const options = () => { try { last = resolveOptions(plainConfig(config)); } catch { /* retain last valid options */ } return last; };
+  const adapter = new AntigravityAdapter({ session, client, models, options,
+    resolveAttachments: () => ctx.get('attachments'),
+    resolveImageAccess: (attachments, ref) => resolveImageAttachmentAccess(attachments, path => ctx.get('fs')?.processPathFromHostPath(path), ref),
+  });
+  const login = new AntigravityLogin({ session, client, models });
+  ctx.provide('dscodeAntigravityLogin', login);
+  ctx.effect(() => () => login.dispose());
+  ctx.inject(['commands'], scoped => registerStartupCommand(scoped, antigravityCommand(login, () => readLanguage())));
+  ctx.llm.registerConfigurableProviders([{ provider: PROVIDER, displayName: 'Antigravity', settingsNs: ctx.fiber.entry?.options.id ?? name, settingsPath: [] }]);
+  const registration = ctx.llm.registerAdapter([PROVIDER], adapter);
+  let policy = JSON.stringify(options().retryPolicy);
+  ctx.on('loader/volatile-update', () => {
+    const next = JSON.stringify(options().retryPolicy);
+    if (next !== policy) { registration.replace([PROVIDER]); policy = next; }
+  });
+}

package/plugins/antigravity/models.mjs

@@ -0,0 +1,80 @@
+import { LlmError } from '@deepseek-ai/dsh-llm';
+
+export const PROVIDER = 'antigravity';
+const positive = n => Number.isSafeInteger(n) && n > 0;
+// Conservative fallback catalog from pi-antigravity d59d22b. Runtime discovery
+// narrows these routes to the variants actually advertised by the account.
+const flash = (version, enums) => ({ id: `gemini-${version}-flash`, name: `Gemini ${version} Flash`, contextWindow: 1048576, maxTokens: 65536,
+  routes: Object.fromEntries(['low', 'medium', 'high'].map((effort, i) => [effort, { id: `gemini-${version}-flash-${effort}`, modelEnum: `MODEL_PLACEHOLDER_M${enums[i]}` }])) });
+export const FALLBACK_MODELS = [flash('3.8', [320, 319, 318]), flash('3.7', [300, 299, 298]), flash('3.6', [73, 72, 71]),
+  { id: 'gemini-3.5-flash', name: 'Gemini 3.5 Flash', contextWindow: 1048576, maxTokens: 65536,
+    routes: { low: { id: 'gemini-3.5-flash-extra-low', modelEnum: 'MODEL_PLACEHOLDER_M187' }, medium: { id: 'gemini-3.5-flash-low', modelEnum: 'MODEL_PLACEHOLDER_M20' }, high: { id: 'gemini-3-flash-agent', modelEnum: 'MODEL_PLACEHOLDER_M84' } } },
+  { id: 'gemini-3.1-pro', name: 'Gemini 3.1 Pro', contextWindow: 1048576, maxTokens: 65535,
+    routes: { low: { id: 'gemini-3.1-pro-low', modelEnum: 'MODEL_PLACEHOLDER_M36' }, high: { id: 'gemini-pro-agent', modelEnum: 'MODEL_PLACEHOLDER_M16' } } },
+];
+
+export function parseModels(data) {
+  if (!data?.models || typeof data.models !== 'object' || Array.isArray(data.models)) throw new LlmError('Antigravity returned an invalid model catalog', 'MALFORMED_RESPONSE');
+  const models = new Map();
+  for (const [runtime, info] of Object.entries(data.models)) {
+    if (!/^gemini-[a-z0-9.-]+$/.test(runtime) || /image|embedding|audio|tts|live|tab|chat|tiered/i.test(runtime) || runtime === 'gemini-3.1-pro-high' || !info || typeof info !== 'object') continue;
+    const known = FALLBACK_MODELS.find(m => Object.values(m.routes).some(r => r.id === runtime));
+    const suffix = runtime.match(/-(low|medium|high)$/)?.[1];
+    const effort = known ? Object.entries(known.routes).find(([, r]) => r.id === runtime)[0] : suffix;
+    const id = known?.id ?? (suffix ? runtime.slice(0, -suffix.length - 1) : runtime);
+    const entry = models.get(id) ?? { id, name: known?.name ?? id, contextWindow: known?.contextWindow ?? 128000, maxTokens: known?.maxTokens ?? 8192, inputModalities: ['text', 'image'], routes: {} };
+    if (info.supportsImages === false) entry.inputModalities = ['text'];
+    if (positive(info.inputTokenLimit)) entry.contextWindow = info.inputTokenLimit;
+    if (positive(info.maxOutputTokens)) entry.maxTokens = info.maxOutputTokens;
+    else if (positive(info.outputTokenLimit)) entry.maxTokens = info.outputTokenLimit;
+    entry.routes[effort ?? 'default'] = { id: runtime,
+      ...(typeof info.model === 'string' ? { modelEnum: info.model } : {}),
+      ...(info.quotaInfo && typeof info.quotaInfo === 'object' ? { quota: info.quotaInfo } : {}) };
+    models.set(id, entry);
+  }
+  return [...models.values()];
+}
+
+export class AntigravityModels {
+  constructor(session, client) { this.session = session; this.client = client; this.clear(); }
+  clear() { this.entries = FALLBACK_MODELS; this.key = undefined; this.checked = 0; this.generation = (this.generation ?? 0) + 1; this.pending = undefined; this.error = undefined; this.discovered = false; }
+  async list(force = false) {
+    const grant = await this.session.current();
+    if (!grant) { if (this.key) this.clear(); return this.entries; }
+    const key = grant.projectId + ':' + grant.refresh;
+    if (this.key !== key) { this.clear(); this.key = key; }
+    if (!force && Date.now() - this.checked < 300000) return this.entries;
+    if (this.pending) return this.pending;
+    const generation = this.generation;
+    this.pending = (async () => {
+      try {
+        const models = parseModels(await this.client.models(await this.session.auth()));
+        if (generation === this.generation) { this.entries = models; this.discovered = true; this.error = undefined; }
+      } catch (error) {
+        if (generation === this.generation) this.error = error instanceof LlmError ? error.message : 'Antigravity model discovery failed';
+      } finally {
+        if (generation === this.generation) { this.checked = Date.now(); this.pending = undefined; }
+      }
+      return this.entries;
+    })();
+    return this.pending;
+  }
+  async get(id) {
+    const model = (await this.list()).find(m => m.id === id);
+    if (!model) throw new LlmError('This Gemini model is not in the Antigravity catalog; refresh with /antigravity models', 'MODEL_NOT_FOUND');
+    return model;
+  }
+}
+
+export function modelRoute(model, effort) {
+  const chosen = effort ?? (model.routes.low ? 'low' : Object.keys(model.routes)[0]);
+  const route = model.routes[chosen];
+  if (!route) throw new LlmError('This Antigravity model does not offer that reasoning effort', 'UNSUPPORTED_REASONING_EFFORT');
+  return { ...route, effort: chosen };
+}
+export function thinkingConfig(route) {
+  if (route.effort === 'default') return undefined;
+  const pro = route.id === 'gemini-pro-agent' || route.id.startsWith('gemini-3.1-pro');
+  const olderFlash = route.id.startsWith('gemini-3.5-flash') || route.id === 'gemini-3-flash-agent';
+  return { includeThoughts: true, thinkingBudget: pro ? (route.effort === 'high' ? 10001 : 1001) : route.effort === 'high' ? (olderFlash ? 10000 : -1) : route.effort === 'medium' ? 4000 : 1000 };
+}

package/plugins/antigravity/oauth.mjs

@@ -0,0 +1,130 @@
+import { createHash, randomBytes } from 'node:crypto';
+import { createServer } from 'node:http';
+import { LlmError } from '@deepseek-ai/dsh-llm';
+
+export const GRANT_REF = 'ANTIGRAVITY_OAUTH';
+export const REDIRECT_URI = 'http://localhost:51121/oauth-callback';
+export const AUTH_URL = 'https://accounts.google.com/o/oauth2/v2/auth';
+export const TOKEN_URL = 'https://oauth2.googleapis.com/token';
+// Public installed-app client distributed by pi-antigravity, not a user secret.
+const CLIENT_ID = '1071006060591-tmhssin2h21lcre235vtolojh4g403ep.apps.googleusercontent.com';
+const CLIENT_SECRET = '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';
+const SCOPES = ['aicode', 'cloud-platform', 'userinfo.email', 'userinfo.profile', 'cclog', 'experimentsandconfigs'].map(scope => `https://www.googleapis.com/auth/${scope}`);
+const MARGIN = 5 * 60 * 1000;
+
+export function authorize() {
+  const verifier = randomBytes(32).toString('base64url'), state = randomBytes(32).toString('base64url');
+  const query = new URLSearchParams({ client_id: CLIENT_ID, redirect_uri: REDIRECT_URI, response_type: 'code',
+    scope: SCOPES.join(' '), access_type: 'offline', prompt: 'consent', state,
+    code_challenge: createHash('sha256').update(verifier).digest('base64url'), code_challenge_method: 'S256' });
+  return { verifier, state, url: `${AUTH_URL}?${query}` };
+}
+
+/** A loopback-only callback; invalid state requests never consume the pending login. */
+export async function callbackServer(state, { port = 51121, timeoutMs = MARGIN, signal } = {}) {
+  let resolveCode, rejectCode, timer, settled = false;
+  const code = new Promise((resolve, reject) => { resolveCode = resolve; rejectCode = reject; });
+  // The browser can finish before the caller attaches its continuation.
+  code.catch(() => {});
+  const finish = (error, value) => {
+    if (settled) return;
+    settled = true; clearTimeout(timer); signal?.removeEventListener('abort', abort);
+    server.close(); server.closeIdleConnections?.();
+    if (error) rejectCode(error); else resolveCode(value);
+  };
+  const abort = () => finish(new Error('Antigravity login cancelled'));
+  const server = createServer((req, res) => {
+    res.setHeader('content-type', 'text/plain; charset=utf-8');
+    res.setHeader('connection', 'close');
+    res.setHeader('cache-control', 'no-store'); res.setHeader('referrer-policy', 'no-referrer');
+    res.setHeader('content-security-policy', "default-src 'none'");
+    let url;
+    try { url = new URL(req.url, REDIRECT_URI); } catch { res.writeHead(400); res.end('Invalid callback URL'); return; }
+    if (req.method !== 'GET' || url.pathname !== '/oauth-callback') { res.writeHead(404); res.end('Not found'); return; }
+    if (url.searchParams.get('state') !== state) { res.writeHead(400); res.end('Invalid login state'); return; }
+    const value = url.searchParams.get('code');
+    if (url.searchParams.has('error') || !value) {
+      res.writeHead(400); res.end('Sign-in was not completed. Return to DSCODE.');
+      finish(new Error('Google sign-in was declined or returned no code')); return;
+    }
+    res.end('Google authorization received. Return to DSCODE and run /antigravity to check completion.');
+    finish(undefined, value);
+  });
+  server.requestTimeout = 5000; server.headersTimeout = 5000;
+  try {
+    signal?.throwIfAborted();
+    await new Promise((resolve, reject) => { server.once('error', reject); server.listen(port, '127.0.0.1', resolve); });
+  } catch { server.close(); throw new Error('Cannot open the Antigravity login callback on 127.0.0.1:51121; close another pending login and retry'); }
+  server.on('error', () => finish(new Error('Antigravity callback failed')));
+  timer = setTimeout(() => finish(new Error('Antigravity login expired; run /antigravity login again')), timeoutMs);
+  timer.unref?.(); signal?.addEventListener('abort', abort, { once: true });
+  if (signal?.aborted) abort();
+  return { code, port: server.address()?.port, close: abort };
+}
+
+async function tokenRequest(body, { fetch = globalThis.fetch, signal } = {}) {
+  const deadline = AbortSignal.timeout(15000);
+  try {
+    const response = await fetch(TOKEN_URL, { method: 'POST', redirect: 'error',
+      headers: { 'content-type': 'application/x-www-form-urlencoded' },
+      body: new URLSearchParams({ client_id: CLIENT_ID, client_secret: CLIENT_SECRET, ...body }),
+      signal: AbortSignal.any([deadline, ...(signal ? [signal] : [])]),
+    });
+    const data = await response.json();
+    if (!response.ok || typeof data.access_token !== 'string' || !data.access_token || !Number.isFinite(data.expires_in) || data.expires_in <= 0) {
+      throw new LlmError('Google could not authorize Antigravity; run /antigravity login again', response.status >= 500 ? 'SERVER' : 'AUTH');
+    }
+    return data;
+  } catch (error) {
+    if (signal?.aborted) throw new LlmError('Antigravity login cancelled', 'ABORTED');
+    if (deadline.aborted) throw new LlmError('Google token request timed out', 'TIMEOUT');
+    if (error instanceof LlmError) throw error;
+    throw new LlmError('Could not contact Google for Antigravity authorization', 'TRANSPORT');
+  }
+}
+
+export async function exchangeCode(code, verifier, client, options = {}) {
+  const token = await tokenRequest({ code, code_verifier: verifier, grant_type: 'authorization_code', redirect_uri: REDIRECT_URI }, options);
+  if (typeof token.refresh_token !== 'string' || !token.refresh_token) throw new LlmError('Google did not issue an offline login; run /antigravity login again', 'AUTH');
+  const projectId = await client.project(token.access_token, options.signal);
+  return { version: 1, access: token.access_token, refresh: token.refresh_token, expires: Date.now() + token.expires_in * 1000, projectId };
+}
+export function parseGrant(raw) {
+  try {
+    const g = JSON.parse(raw);
+    return g?.version === 1 && ['access', 'refresh', 'projectId'].every(k => typeof g[k] === 'string' && g[k]) && Number.isFinite(g.expires) ? g : undefined;
+  } catch { return undefined; }
+}
+
+/** Serialize writes so a late callback or refresh cannot undo logout in this Host. */
+export class AntigravitySession {
+  constructor(store, { fetch, now = Date.now } = {}) { this.store = store; this.fetch = fetch; this.now = now; this.revision = 0; this.writes = Promise.resolve(); }
+  current() { return this.store.read().then(parseGrant); }
+  write(action) { const next = this.writes.then(action); this.writes = next.catch(() => {}); return next; }
+  save(grant, revision = this.revision) {
+    return this.write(async () => {
+      if (revision !== this.revision) return false;
+      await this.store.write(JSON.stringify(grant)); return true;
+    });
+  }
+  logout() { this.revision++; return this.write(() => this.store.remove()); }
+  async auth() {
+    const grant = await this.current();
+    if (!grant) throw new LlmError('Sign in with /antigravity login first', 'MISSING_CREDENTIAL');
+    if (grant.expires - this.now() > MARGIN) return grant;
+    if (!this.pending) {
+      const revision = this.revision;
+      this.pending = (async () => {
+        const token = await tokenRequest({ grant_type: 'refresh_token', refresh_token: grant.refresh }, { fetch: this.fetch });
+        return this.write(async () => {
+          const current = await this.current();
+          if (!current || revision !== this.revision) throw new LlmError('Antigravity signed out during token refresh', 'MISSING_CREDENTIAL');
+          if (current.access !== grant.access || current.refresh !== grant.refresh) return current;
+          const next = { ...grant, access: token.access_token, refresh: token.refresh_token || grant.refresh, expires: this.now() + token.expires_in * 1000 };
+          await this.store.write(JSON.stringify(next)); return next;
+        });
+      })().finally(() => { this.pending = undefined; });
+    }
+    return this.pending;
+  }
+}