@lay111/dsh-plugin-google 1.0.0

package/README.md

@@ -0,0 +1,40 @@
+# dsh-plugin-google (Google Antigravity Native Plugin for DSH)
+
+原生 DeepSeek Harness / Cordis 插件，为 DSH 提供零代理（Zero-Proxy）直连 Google Antigravity Pro 订阅及全部大模型的能力。
+
+## 🌟 支持的模型列表
+
+- `gemini-3.7-flash`: **Gemini 3.7 Flash High (10k Thinking Budget)** (默认旗舰)
+- `gemini-3.7-flash-standard`: **Gemini 3.7 Flash (Standard)**
+- `gemini-3.6-flash`: **Gemini 3.6 Flash**
+- `gemini-3.5-flash`: **Gemini 3.5 Flash**
+- `gemini-3.1-pro`: **Gemini 3.1 Pro (Agent)**
+- `claude-sonnet-4.6`: **Claude Sonnet 4.6 (Thinking)**
+- `claude-opus-4.6`: **Claude Opus 4.6 (Thinking)**
+- `gpt-oss-120b`: **GPT-OSS 120B (Medium)**
+
+## 🚀 如何在 DSH 中挂载此插件
+
+在你的 profile 的 `cordis.patch.yml` 中添加：
+
+```yaml
+- id: dsh-antigravity
+  name: /home/lay/test
+```
+
+或者设置默认模型为：
+```yaml
+agent-default-model:
+  provider: antigravity
+  model: gemini-3.7-flash
+```
+
+## 🔑 认证管理
+
+```bash
+# 登录 Google 账号：
+node /home/lay/test/bin/auth-cli.js login
+
+# 查看登录状态：
+node /home/lay/test/bin/auth-cli.js status
+```

package/bin/auth-cli.js

@@ -0,0 +1,35 @@
+#!/usr/bin/env node
+import { startGoogleOAuthLogin, getActiveAccount, loadTokens, saveTokens } from '../src/auth.js';
+
+const cmd = process.argv[2];
+
+if (cmd === 'login') {
+  startGoogleOAuthLogin()
+    .then((acc) => {
+      console.log(`\n🎉 Logged in successfully: ${acc.email}`);
+      process.exit(0);
+    })
+    .catch((err) => {
+      console.error('Login error:', err);
+      process.exit(1);
+    });
+} else if (cmd === 'status') {
+  const active = getActiveAccount();
+  const tokens = loadTokens();
+  console.log(`Google Antigravity Auth Status:`);
+  console.log(`  Active Account: ${active ? active.email : 'None'}`);
+  console.log(`  Project ID: ${active ? active.projectId : 'N/A'}`);
+  console.log(`  Total Accounts: ${tokens.accounts.length}`);
+  process.exit(0);
+} else if (cmd === 'logout') {
+  saveTokens({ accounts: [], activeAccount: null });
+  console.log('Cleared all saved Google accounts.');
+  process.exit(0);
+} else {
+  console.log(`Usage:
+  node bin/auth-cli.js login     # Start Google OAuth login flow
+  node bin/auth-cli.js status    # Show current login status
+  node bin/auth-cli.js logout    # Clear saved credentials
+`);
+  process.exit(0);
+}

package/bin/setup.js

@@ -0,0 +1,152 @@
+#!/usr/bin/env node
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import { spawnSync } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+import { startGoogleOAuthLogin, getActiveAccount } from '../src/auth.js';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const PLUGIN_ROOT = path.resolve(__dirname, '..');
+
+const HOME = os.homedir();
+const DSH_HOME = path.join(HOME, '.dsh');
+const DSH_TUI_HOME = path.join(HOME, '.dsh-tui');
+const LOCAL_BIN = path.join(HOME, '.local', 'bin');
+
+console.log(`
+╭──────────────────────────────────────────────────────────╮
+│   DeepSeek Harness · Google Antigravity One-Click Setup  │
+│   全自动配置 TUI / Web / 全局 Google Pro 满血模型矩阵     │
+╰──────────────────────────────────────────────────────────╯
+`);
+
+// 1. Ensure required directories
+fs.mkdirSync(DSH_HOME, { recursive: true });
+fs.mkdirSync(DSH_TUI_HOME, { recursive: true });
+fs.mkdirSync(LOCAL_BIN, { recursive: true });
+fs.mkdirSync(path.join(DSH_HOME, 'profiles', 'dsh-tui'), { recursive: true });
+fs.mkdirSync(path.join(DSH_HOME, 'profiles', 'web'), { recursive: true });
+
+console.log('📦 [1/4] 配置全局 DSH 默认设置...');
+// 2. Configure ~/.dsh/settings.yaml
+const settingsPath = path.join(DSH_HOME, 'settings.yaml');
+const settingsContent = `agent-default-model:
+  provider: antigravity
+  model: gemini-3.7-flash
+`;
+fs.writeFileSync(settingsPath, settingsContent, 'utf-8');
+
+console.log('🎨 [2/4] 挂载插件至 TUI & Web 运行时 Profile...');
+// 3. Configure TUI Profile
+const tuiPatchPath = path.join(DSH_HOME, 'profiles', 'dsh-tui', 'cordis.patch.yml');
+const tuiPatchContent = `- id: dsh-antigravity
+  name: ${PLUGIN_ROOT}
+
+- id: dsh-tui
+  name: '@deepseek-harness-tui/dsh-tui'
+  config:
+    provider: antigravity
+    model: gemini-3.7-flash
+    fullscreen: true
+`;
+fs.writeFileSync(tuiPatchPath, tuiPatchContent, 'utf-8');
+
+const tuiPkgPath = path.join(DSH_HOME, 'profiles', 'dsh-tui', 'package.json');
+if (!fs.existsSync(tuiPkgPath)) {
+  fs.writeFileSync(
+    tuiPkgPath,
+    JSON.stringify(
+      {
+        name: 'dsh-profile-dsh-tui',
+        private: true,
+        dependencies: { '@deepseek-harness-tui/dsh-tui': '^0.9.3' },
+        dsh: { profile: { bundles: ['@deepseek-ai/dsh-base', '@deepseek-harness-tui/dsh-tui'] } },
+      },
+      null,
+      2,
+    ),
+    'utf-8',
+  );
+}
+
+// 4. Configure Web Profile
+const webPatchPath = path.join(DSH_HOME, 'profiles', 'web', 'cordis.patch.yml');
+const webPatchContent = `- id: dsh-antigravity
+  name: ${PLUGIN_ROOT}
+`;
+fs.writeFileSync(webPatchPath, webPatchContent, 'utf-8');
+
+const webPkgPath = path.join(DSH_HOME, 'profiles', 'web', 'package.json');
+if (!fs.existsSync(webPkgPath)) {
+  fs.writeFileSync(
+    webPkgPath,
+    JSON.stringify(
+      {
+        name: 'dsh-profile-web',
+        private: true,
+        dsh: { profile: { bundles: ['@deepseek-ai/dsh-base', '@deepseek-ai/dsh-web-app'] } },
+      },
+      null,
+      2,
+    ),
+    'utf-8',
+  );
+}
+
+// 5. Configure ~/.dsh-tui preferences
+fs.writeFileSync(
+  path.join(DSH_TUI_HOME, 'model.json'),
+  JSON.stringify({ provider: 'antigravity', model: 'gemini-3.7-flash' }, null, 2),
+  'utf-8',
+);
+fs.writeFileSync(
+  path.join(DSH_TUI_HOME, 'model-recents.json'),
+  JSON.stringify({ models: [{ provider: 'antigravity', id: 'gemini-3.7-flash' }] }, null, 2),
+  'utf-8',
+);
+
+console.log('🔗 [3/4] 注册全局快捷命令 (dst / dsh-google-auth)...');
+const tuiBin = path.join(DSH_HOME, 'profiles', 'dsh-tui', 'node_modules', '@deepseek-harness-tui', 'dsh-tui', 'bin', 'dsh-tui.js');
+if (fs.existsSync(tuiBin)) {
+  try {
+    fs.unlinkSync(path.join(LOCAL_BIN, 'dst'));
+    fs.unlinkSync(path.join(LOCAL_BIN, 'dsh-tui'));
+  } catch {}
+  try {
+    fs.symlinkSync(tuiBin, path.join(LOCAL_BIN, 'dst'));
+    fs.symlinkSync(tuiBin, path.join(LOCAL_BIN, 'dsh-tui'));
+  } catch {}
+}
+
+try {
+  fs.unlinkSync(path.join(LOCAL_BIN, 'dsh-google-auth'));
+} catch {}
+try {
+  fs.symlinkSync(path.join(PLUGIN_ROOT, 'bin', 'auth-cli.js'), path.join(LOCAL_BIN, 'dsh-google-auth'));
+} catch {}
+
+console.log('🔑 [4/4] 检查 Google 账号登录状态...');
+const active = getActiveAccount();
+
+async function runLogin() {
+  if (active) {
+    console.log(`\n✓ 当前已登录账号: ${active.email} (项目: ${active.projectId})`);
+    console.log(`\n🎉 安装完成！你可以直接输入以下命令启动：`);
+    console.log(`  👉 终端全屏 TUI 模式: dst`);
+    console.log(`  👉 本地 Web 浏览器模式: dsh web\n`);
+  } else {
+    console.log(`\n未检测到已登录的 Google 账号，正在为你唤起浏览器授权登录...`);
+    try {
+      const account = await startGoogleOAuthLogin();
+      console.log(`\n🎉 登录成功: ${account.email}！`);
+      console.log(`\n🎉 所有配置已就绪！你可以直接输入：`);
+      console.log(`  👉 终端全屏 TUI 模式: dst`);
+      console.log(`  👉 本地 Web 浏览器模式: dsh web\n`);
+    } catch (err) {
+      console.log(`\n若浏览器未自动完成，可随时在终端运行 dsh-google-auth login 手动完成登录。`);
+    }
+  }
+}
+
+runLogin();

package/install.sh

@@ -0,0 +1,13 @@
+#!/usr/bin/env bash
+set -e
+
+echo "🚀 开始一键安装 DeepSeek Harness + Google Antigravity 原生支持..."
+
+# 1. 确保安装了 dsh 官方底座
+if ! command -v dsh &> /dev/null; then
+  echo "📦 正在安装 @deepseek-ai/dsh 底层引擎..."
+  npm install -g @deepseek-ai/dsh
+fi
+
+# 2. 执行自动化配置脚本
+node "$(dirname "$0")/bin/setup.js"

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@lay111/dsh-plugin-google",
+  "version": "1.0.0",
+  "description": "Native DeepSeek Harness Plugin for Google Antigravity Pro & Gemini/Claude Models",
+  "type": "module",
+  "main": "src/index.js",
+  "exports": {
+    ".": "./src/index.js",
+    "./package.json": "./package.json"
+  },
+  "bin": {
+    "dsh-google-setup": "bin/setup.js",
+    "dsh-google-auth": "bin/auth-cli.js"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "src",
+    "bin",
+    "install.sh",
+    "README.md"
+  ],
+  "peerDependencies": {
+    "@deepseek-ai/cordis": "^4.0.1",
+    "@deepseek-ai/dsh-llm": "^0.1.0-rc.6 || ^0.1.1-rc.2",
+    "@deepseek-ai/dsh-commands": "^0.1.0-rc.6 || ^0.1.1-rc.2"
+  },
+  "peerDependenciesMeta": {
+    "@deepseek-ai/dsh-commands": {
+      "optional": true
+    }
+  },
+  "keywords": [
+    "deepseek-harness",
+    "dsh",
+    "cordis",
+    "antigravity",
+    "gemini",
+    "claude",
+    "plugin"
+  ],
+  "author": "lay111",
+  "license": "MIT"
+}

package/src/adapter.js

@@ -0,0 +1,48 @@
+import { ANTIGRAVITY_MODELS, findModel } from './models.js';
+import { getValidAccessToken } from './auth.js';
+import { streamAntigravity } from './api.js';
+
+export class AntigravityLlmAdapter {
+  providerInfo(provider) {
+    return {
+      id: 'antigravity',
+      name: 'Google Antigravity Pro',
+    };
+  }
+
+  providerRetryPolicy(provider) {
+    return undefined;
+  }
+
+  async listModels(provider) {
+    return ANTIGRAVITY_MODELS.map((model) => ({
+      provider: 'antigravity',
+      id: model.id,
+      name: model.name,
+      description: model.description,
+      inputModalities: ['text'],
+    }));
+  }
+
+  async resolveModelInfo(provider, modelId, signal) {
+    const model = findModel(modelId);
+    return {
+      provider: 'antigravity',
+      id: model.id,
+      name: model.name,
+      contextWindow: model.contextWindow,
+      maxTokens: model.maxTokens,
+      reasoningEfforts: model.supportsThinking
+        ? [
+            { id: 'high', name: 'High Thinking' },
+            { id: 'low', name: 'Low Thinking' },
+          ]
+        : undefined,
+    };
+  }
+
+  async *generate(options, runtime) {
+    const { accessToken, projectId } = await getValidAccessToken();
+    yield* streamAntigravity(options, accessToken, projectId);
+  }
+}

package/src/api.js

@@ -0,0 +1,178 @@
+import { USER_AGENT } from './auth.js';
+import { findModel } from './models.js';
+
+const ANTIGRAVITY_ENDPOINT = 'https://cloudaicompanion.googleapis.com/v1:streamGenerateChat';
+
+export function formatMessagesToAntigravity(messages, modelSpec, projectId) {
+  const contents = [];
+  let systemInstruction = null;
+
+  for (const message of messages) {
+    if (message.role === 'system') {
+      systemInstruction = {
+        parts: [{ text: typeof message.content === 'string' ? message.content : '' }],
+      };
+      continue;
+    }
+
+    const parts = [];
+    if (typeof message.content === 'string') {
+      if (message.content.length > 0) {
+        parts.push({ text: message.content });
+      }
+    } else if (Array.isArray(message.content)) {
+      for (const block of message.content) {
+        if (block.type === 'text') {
+          parts.push({ text: block.text });
+        } else if (block.type === 'thought') {
+          parts.push({ thought: true, text: block.text });
+        } else if (block.type === 'tool-call') {
+          parts.push({
+            functionCall: {
+              name: block.name,
+              args: typeof block.arguments === 'string' ? JSON.parse(block.arguments || '{}') : block.arguments || {},
+            },
+          });
+        } else if (block.type === 'tool-result') {
+          contents.push({
+            role: 'user',
+            parts: [
+              {
+                functionResponse: {
+                  name: block.name || 'tool',
+                  response: { result: block.content },
+                },
+              },
+            ],
+          });
+        }
+      }
+    }
+
+    if (parts.length > 0) {
+      contents.push({
+        role: message.role === 'assistant' ? 'model' : 'user',
+        parts,
+      });
+    }
+  }
+
+  const payload = {
+    project: projectId || 'aicode-consumers',
+    model: modelSpec.wireId,
+    request: {
+      contents,
+    },
+  };
+
+  if (modelSpec.supportsThinking) {
+    payload.request.generationConfig = {
+      thinkingConfig: {
+        includeThoughts: true,
+        thinkingBudget: modelSpec.thinkingBudget || 10000,
+      },
+    };
+  }
+
+  if (systemInstruction) {
+    payload.request.systemInstruction = systemInstruction;
+  }
+
+  return payload;
+}
+
+export async function* streamAntigravity(options, accessToken, projectId) {
+  const modelSpec = findModel(options.model);
+  const payload = formatMessagesToAntigravity(options.messages || [], modelSpec, projectId);
+
+  if (options.tools && options.tools.length > 0) {
+    payload.request.tools = [
+      {
+        functionDeclarations: options.tools.map((tool) => ({
+          name: tool.name,
+          description: tool.description || '',
+          parameters: tool.parameters || {},
+        })),
+      },
+    ];
+  }
+
+  const response = await fetch(ANTIGRAVITY_ENDPOINT, {
+    method: 'POST',
+    headers: {
+      Authorization: `Bearer ${accessToken}`,
+      'Content-Type': 'application/json',
+      'User-Agent': USER_AGENT,
+    },
+    body: JSON.stringify(payload),
+    signal: options.signal,
+  });
+
+  if (!response.ok) {
+    const errorText = await response.text();
+    throw new Error(`Google API Error (${response.status}): ${errorText}`);
+  }
+
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = '';
+  let blockIndex = 0;
+
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split('\n');
+      buffer = lines.pop() || '';
+
+      for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed) continue;
+
+        try {
+          const item = JSON.parse(trimmed);
+          const candidate = item.response?.candidates?.[0];
+          if (!candidate) continue;
+
+          for (const part of candidate.content?.parts || []) {
+            if (part.thought) {
+              yield {
+                type: 'reasoning-delta',
+                index: blockIndex,
+                text: part.text || '',
+              };
+            } else if (part.text) {
+              yield {
+                type: 'text-delta',
+                index: blockIndex,
+                text: part.text || '',
+              };
+            } else if (part.functionCall) {
+              const callId = `call_${Math.random().toString(36).slice(2, 10)}`;
+              yield {
+                type: 'tool-call-delta',
+                index: blockIndex++,
+                id: callId,
+                name: part.functionCall.name,
+                argumentsDelta: JSON.stringify(part.functionCall.args || {}),
+              };
+            }
+          }
+
+          if (candidate.finishReason) {
+            yield {
+              type: 'finish',
+              reason: candidate.finishReason.toLowerCase() === 'stop' ? 'stop' : 'stop',
+            };
+          }
+        } catch {
+          // ignore partial json
+        }
+      }
+    }
+  } finally {
+    reader.releaseLock();
+  }
+}

package/src/auth.js

@@ -0,0 +1,252 @@
+import http from 'node:http';
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import { spawn } from 'node:child_process';
+
+const CONFIG_DIR = path.join(os.homedir(), '.antigravity-proxy');
+const TOKENS_FILE = path.join(CONFIG_DIR, 'tokens.json');
+
+export const OAUTH_CLIENT_ID =
+  '1071006060591-tmhssin2h21lcre235vtolojh4g403ep.apps.googleusercontent.com';
+export const OAUTH_CLIENT_SECRET = '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';
+export const OAUTH_REDIRECT_PORT = 51121;
+export const OAUTH_REDIRECT_URI = `http://127.0.0.1:${OAUTH_REDIRECT_PORT}/oauth-callback`;
+
+export const SCOPES = [
+  'https://www.googleapis.com/auth/cloud-platform',
+  'https://www.googleapis.com/auth/userinfo.email',
+  'https://www.googleapis.com/auth/userinfo.profile',
+  'https://www.googleapis.com/auth/cclog',
+  'https://www.googleapis.com/auth/experimentsandconfigs',
+];
+
+export const USER_AGENT = `antigravity/hub/2.8.0 (aidev_client; os_type=${process.platform}; arch=${process.arch}; cl=963137146)`;
+
+export function ensureConfigDir() {
+  if (!fs.existsSync(CONFIG_DIR)) {
+    fs.mkdirSync(CONFIG_DIR, { recursive: true });
+  }
+}
+
+export function loadTokens() {
+  try {
+    if (fs.existsSync(TOKENS_FILE)) {
+      return JSON.parse(fs.readFileSync(TOKENS_FILE, 'utf-8'));
+    }
+  } catch (err) {
+    // ignore
+  }
+  return { accounts: [], activeAccount: null };
+}
+
+export function saveTokens(data) {
+  ensureConfigDir();
+  fs.writeFileSync(TOKENS_FILE, JSON.stringify(data, null, 2), { mode: 0o600 });
+}
+
+export function getActiveAccount() {
+  const data = loadTokens();
+  if (!data.activeAccount || !data.accounts || data.accounts.length === 0) {
+    return null;
+  }
+  return data.accounts.find((acc) => acc.email === data.activeAccount) || null;
+}
+
+export function updateAccount(account) {
+  const data = loadTokens();
+  const index = data.accounts.findIndex((acc) => acc.email === account.email);
+  if (index >= 0) {
+    data.accounts[index] = account;
+  } else {
+    data.accounts.push(account);
+  }
+  data.activeAccount = account.email;
+  saveTokens(data);
+}
+
+export function getAuthorizationUrl() {
+  const params = new URLSearchParams({
+    client_id: OAUTH_CLIENT_ID,
+    redirect_uri: OAUTH_REDIRECT_URI,
+    response_type: 'code',
+    scope: SCOPES.join(' '),
+    access_type: 'offline',
+    prompt: 'select_account consent',
+  });
+  return `https://accounts.google.com/o/oauth2/v2/auth?${params.toString()}`;
+}
+
+export async function exchangeCodeForTokens(code) {
+  const response = await fetch('https://oauth2.googleapis.com/token', {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+    body: new URLSearchParams({
+      code,
+      client_id: OAUTH_CLIENT_ID,
+      client_secret: OAUTH_CLIENT_SECRET,
+      redirect_uri: OAUTH_REDIRECT_URI,
+      grant_type: 'authorization_code',
+    }),
+  });
+
+  if (!response.ok) {
+    const errorText = await response.text();
+    throw new Error(`Exchange code failed: ${errorText}`);
+  }
+
+  return response.json();
+}
+
+export async function refreshAccessToken(refreshToken) {
+  const response = await fetch('https://oauth2.googleapis.com/token', {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+    body: new URLSearchParams({
+      refresh_token: refreshToken,
+      client_id: OAUTH_CLIENT_ID,
+      client_secret: OAUTH_CLIENT_SECRET,
+      grant_type: 'refresh_token',
+    }),
+  });
+
+  if (!response.ok) {
+    const errorText = await response.text();
+    throw new Error(`Token refresh failed: ${errorText}`);
+  }
+
+  return response.json();
+}
+
+export async function getUserInfo(accessToken) {
+  const response = await fetch('https://www.googleapis.com/oauth2/v2/userinfo', {
+    headers: { Authorization: `Bearer ${accessToken}` },
+  });
+  if (!response.ok) {
+    throw new Error(`Get userinfo failed: ${response.statusText}`);
+  }
+  return response.json();
+}
+
+export async function discoverProjectId(accessToken) {
+  const endpoints = [
+    'https://daily-cloudcode-pa.googleapis.com/v1internal:loadCodeAssist',
+    'https://cloudaicompanion.googleapis.com/v1:loadContext',
+  ];
+
+  for (const endpoint of endpoints) {
+    try {
+      const response = await fetch(endpoint, {
+        method: 'POST',
+        headers: {
+          Authorization: `Bearer ${accessToken}`,
+          'Content-Type': 'application/json',
+          'User-Agent': USER_AGENT,
+        },
+        body: JSON.stringify({}),
+      });
+
+      if (response.ok) {
+        const data = await response.json();
+        if (data.cloudaicompanionProjectNumber) {
+          return String(data.cloudaicompanionProjectNumber);
+        }
+        if (data.projectNumber) {
+          return String(data.projectNumber);
+        }
+      }
+    } catch {
+      // Continue
+    }
+  }
+  return 'aicode-consumers';
+}
+
+export async function getValidAccessToken() {
+  const account = getActiveAccount();
+  if (!account) {
+    throw new Error('No Google account logged in. Please run `dsh-google-auth login` or `/auth/google` in DSH.');
+  }
+
+  if (Date.now() > account.expiresAt - 120000) {
+    const refreshed = await refreshAccessToken(account.refreshToken);
+    account.accessToken = refreshed.access_token;
+    account.expiresAt = Date.now() + refreshed.expires_in * 1000;
+    updateAccount(account);
+  }
+
+  return {
+    accessToken: account.accessToken,
+    projectId: account.projectId || 'aicode-consumers',
+    email: account.email,
+  };
+}
+
+export async function startGoogleOAuthLogin() {
+  const authUrl = getAuthorizationUrl();
+  console.log(`\n======================================================`);
+  console.log(`🔑 Google Antigravity Pro OAuth Login`);
+  console.log(`Opening browser: ${authUrl}\n======================================================\n`);
+
+  try {
+    spawn('xdg-open', [authUrl], { detached: true, stdio: 'ignore' }).unref();
+  } catch {}
+
+  return new Promise((resolve, reject) => {
+    let handled = false;
+    const server = http.createServer(async (req, res) => {
+      const url = new URL(req.url, `http://127.0.0.1:${OAUTH_REDIRECT_PORT}`);
+      if (url.pathname === '/oauth-callback' || url.pathname === '/oauth/callback') {
+        const code = url.searchParams.get('code');
+        const error = url.searchParams.get('error');
+
+        if (error) {
+          res.writeHead(400, { 'Content-Type': 'text/html; charset=utf-8' });
+          res.end('<h1>Authorization Failed</h1>');
+          if (!handled) {
+            handled = true;
+            server.close();
+            reject(new Error(error));
+          }
+          return;
+        }
+
+        if (code) {
+          try {
+            res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
+            res.end('<h1>Authorization Successful! You can close this window now.</h1>');
+
+            const tokens = await exchangeCodeForTokens(code);
+            const userInfo = await getUserInfo(tokens.access_token);
+            const projectId = await discoverProjectId(tokens.access_token);
+
+            const account = {
+              email: userInfo.email,
+              name: userInfo.name || userInfo.email,
+              accessToken: tokens.access_token,
+              refreshToken: tokens.refresh_token,
+              expiresAt: Date.now() + tokens.expires_in * 1000,
+              projectId,
+              isActive: true,
+            };
+
+            updateAccount(account);
+            if (!handled) {
+              handled = true;
+              server.close();
+              resolve(account);
+            }
+          } catch (err) {
+            if (!handled) {
+              handled = true;
+              server.close();
+              reject(err);
+            }
+          }
+        }
+      }
+    });
+
+    server.listen(OAUTH_REDIRECT_PORT, '127.0.0.1');
+  });
+}

package/src/index.js

@@ -0,0 +1,38 @@
+import { AntigravityLlmAdapter } from './adapter.js';
+import { startGoogleOAuthLogin, getActiveAccount } from './auth.js';
+
+export const name = 'dsh-antigravity';
+export const inject = ['llm'];
+
+export function apply(ctx) {
+  const adapter = new AntigravityLlmAdapter();
+
+  // 1. Register the native LLM adapter with DeepSeek Harness
+  ctx.llm.registerAdapter(['antigravity'], adapter);
+
+  // 2. Register slash command if commands service is present
+  if (ctx.commands) {
+    ctx.commands.command('auth/google', 'Log in to Google Antigravity Pro').action(async () => {
+      console.log('Initiating Google OAuth login flow...');
+      const account = await startGoogleOAuthLogin();
+      console.log(`Successfully logged in as: ${account.email}`);
+    });
+
+    ctx.commands.command('auth/status', 'Check Google Antigravity account status').action(() => {
+      const active = getActiveAccount();
+      if (active) {
+        console.log(`Active Account: ${active.email} (Project: ${active.projectId})`);
+      } else {
+        console.log('No Google Antigravity account currently logged in.');
+      }
+    });
+  }
+
+  ctx.logger?.info('Google Antigravity plugin mounted successfully.');
+}
+
+export default {
+  name,
+  inject,
+  apply,
+};

package/src/models.js

@@ -0,0 +1,86 @@
+export const ANTIGRAVITY_MODELS = [
+  {
+    id: 'gemini-3.7-flash',
+    name: 'Gemini 3.7 Flash High (Thinking)',
+    wireId: 'gemini-3.7-flash-high',
+    contextWindow: 1048576,
+    maxTokens: 65536,
+    supportsThinking: true,
+    thinkingBudget: 10000,
+    description: 'Google flagship coding model with 10k thinking budget (Fast & Deep)',
+  },
+  {
+    id: 'gemini-3.7-flash-standard',
+    name: 'Gemini 3.7 Flash (Standard)',
+    wireId: 'gemini-3.7-flash',
+    contextWindow: 1048576,
+    maxTokens: 65536,
+    supportsThinking: false,
+    description: 'Standard low-latency mode without extended thinking',
+  },
+  {
+    id: 'gemini-3.6-flash',
+    name: 'Gemini 3.6 Flash',
+    wireId: 'gemini-3.6-flash',
+    contextWindow: 1048576,
+    maxTokens: 65536,
+    supportsThinking: true,
+    thinkingBudget: 4000,
+    description: 'Fast lightweight Flash model',
+  },
+  {
+    id: 'gemini-3.5-flash',
+    name: 'Gemini 3.5 Flash',
+    wireId: 'gemini-3.5-flash',
+    contextWindow: 1048576,
+    maxTokens: 65536,
+    supportsThinking: true,
+    thinkingBudget: 4000,
+    description: 'Classic Flash model',
+  },
+  {
+    id: 'gemini-3.1-pro',
+    name: 'Gemini 3.1 Pro (Agent)',
+    wireId: 'gemini-3.1-pro-low',
+    contextWindow: 1048576,
+    maxTokens: 65536,
+    supportsThinking: true,
+    thinkingBudget: 8000,
+    description: 'Pro-tier deep reasoning agent model',
+  },
+  {
+    id: 'claude-sonnet-4.6',
+    name: 'Claude Sonnet 4.6 (Thinking)',
+    wireId: 'claude-sonnet-4-6-thinking',
+    contextWindow: 200000,
+    maxTokens: 64000,
+    supportsThinking: true,
+    description: 'Anthropic Claude Sonnet with reasoning chain via Antigravity',
+  },
+  {
+    id: 'claude-opus-4.6',
+    name: 'Claude Opus 4.6 (Thinking)',
+    wireId: 'claude-opus-4-6-thinking',
+    contextWindow: 200000,
+    maxTokens: 64000,
+    supportsThinking: true,
+    description: 'Anthropic Claude Opus for highest-tier architecture and logic modeling',
+  },
+  {
+    id: 'gpt-oss-120b',
+    name: 'GPT-OSS 120B (Medium)',
+    wireId: 'gpt-oss-120b-medium',
+    contextWindow: 128000,
+    maxTokens: 32768,
+    supportsThinking: true,
+    description: 'Open source 120B parameter reasoning model',
+  },
+];
+
+export function findModel(id) {
+  return (
+    ANTIGRAVITY_MODELS.find((m) => m.id === id) ||
+    ANTIGRAVITY_MODELS.find((m) => m.wireId === id) ||
+    ANTIGRAVITY_MODELS[0]
+  );
+}