@workclaw/openclaw-workclaw 1.0.202 → 1.0.332

package/dist/node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/node_modules/@mariozechner/pi-ai/dist/utils/oauth/google-gemini-cli.js

@@ -0,0 +1,402 @@
+import { oauthErrorHtml, oauthSuccessHtml } from "./oauth-page.js";
+import { generatePKCE } from "./pkce.js";
+let _createServer = null;
+let _httpImportPromise = null;
+if (typeof process !== "undefined" && (process.versions?.node || process.versions?.bun)) {
+  _httpImportPromise = import("node:http").then((m) => {
+    _createServer = m.createServer;
+  });
+}
+const decode = (s) => atob(s);
+const CLIENT_ID = decode("NjgxMjU1ODA5Mzk1LW9vOGZ0Mm9wcmRybnA5ZTNhcWY2YXYzaG1kaWIxMzVqLmFwcHMuZ29vZ2xldXNlcmNvbnRlbnQuY29t");
+const CLIENT_SECRET = decode("R09DU1BYLTR1SGdNUG0tMW83U2stZ2VWNkN1NWNsWEZzeGw=");
+const REDIRECT_URI = "http://localhost:8085/oauth2callback";
+const SCOPES = [
+  "https://www.googleapis.com/auth/cloud-platform",
+  "https://www.googleapis.com/auth/userinfo.email",
+  "https://www.googleapis.com/auth/userinfo.profile"
+];
+const AUTH_URL = "https://accounts.google.com/o/oauth2/v2/auth";
+const TOKEN_URL = "https://oauth2.googleapis.com/token";
+const CODE_ASSIST_ENDPOINT = "https://cloudcode-pa.googleapis.com";
+async function getNodeCreateServer() {
+  if (_createServer)
+    return _createServer;
+  if (_httpImportPromise) {
+    await _httpImportPromise;
+  }
+  if (_createServer)
+    return _createServer;
+  throw new Error("Gemini CLI OAuth is only available in Node.js environments");
+}
+async function startCallbackServer() {
+  const createServer = await getNodeCreateServer();
+  return new Promise((resolve, reject) => {
+    let settleWait;
+    const waitForCodePromise = new Promise((resolveWait) => {
+      let settled = false;
+      settleWait = (value) => {
+        if (settled)
+          return;
+        settled = true;
+        resolveWait(value);
+      };
+    });
+    const server = createServer((req, res) => {
+      const url = new URL(req.url || "", `http://localhost:8085`);
+      if (url.pathname === "/oauth2callback") {
+        const code = url.searchParams.get("code");
+        const state = url.searchParams.get("state");
+        const error = url.searchParams.get("error");
+        if (error) {
+          res.writeHead(400, { "Content-Type": "text/html; charset=utf-8" });
+          res.end(oauthErrorHtml("Google authentication did not complete.", `Error: ${error}`));
+          return;
+        }
+        if (code && state) {
+          res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
+          res.end(oauthSuccessHtml("Google authentication completed. You can close this window."));
+          settleWait?.({ code, state });
+        } else {
+          res.writeHead(400, { "Content-Type": "text/html; charset=utf-8" });
+          res.end(oauthErrorHtml("Missing code or state parameter."));
+        }
+      } else {
+        res.writeHead(404, { "Content-Type": "text/html; charset=utf-8" });
+        res.end(oauthErrorHtml("Callback route not found."));
+      }
+    });
+    server.on("error", (err) => {
+      reject(err);
+    });
+    server.listen(8085, "127.0.0.1", () => {
+      resolve({
+        server,
+        cancelWait: () => {
+          settleWait?.(null);
+        },
+        waitForCode: () => waitForCodePromise
+      });
+    });
+  });
+}
+function parseRedirectUrl(input) {
+  const value = input.trim();
+  if (!value)
+    return {};
+  try {
+    const url = new URL(value);
+    return {
+      code: url.searchParams.get("code") ?? void 0,
+      state: url.searchParams.get("state") ?? void 0
+    };
+  } catch {
+    return {};
+  }
+}
+const TIER_FREE = "free-tier";
+const TIER_LEGACY = "legacy-tier";
+const TIER_STANDARD = "standard-tier";
+function wait(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function getDefaultTier(allowedTiers) {
+  if (!allowedTiers || allowedTiers.length === 0)
+    return { id: TIER_LEGACY };
+  const defaultTier = allowedTiers.find((t) => t.isDefault);
+  return defaultTier ?? { id: TIER_LEGACY };
+}
+function isVpcScAffectedUser(payload) {
+  if (!payload || typeof payload !== "object")
+    return false;
+  if (!("error" in payload))
+    return false;
+  const error = payload.error;
+  if (!error?.details || !Array.isArray(error.details))
+    return false;
+  return error.details.some((detail) => detail.reason === "SECURITY_POLICY_VIOLATED");
+}
+async function pollOperation(operationName, headers, onProgress) {
+  let attempt = 0;
+  while (true) {
+    if (attempt > 0) {
+      onProgress?.(`Waiting for project provisioning (attempt ${attempt + 1})...`);
+      await wait(5e3);
+    }
+    const response = await fetch(`${CODE_ASSIST_ENDPOINT}/v1internal/${operationName}`, {
+      method: "GET",
+      headers
+    });
+    if (!response.ok) {
+      throw new Error(`Failed to poll operation: ${response.status} ${response.statusText}`);
+    }
+    const data = await response.json();
+    if (data.done) {
+      return data;
+    }
+    attempt += 1;
+  }
+}
+async function discoverProject(accessToken, onProgress) {
+  const envProjectId = process.env.GOOGLE_CLOUD_PROJECT || process.env.GOOGLE_CLOUD_PROJECT_ID;
+  const headers = {
+    Authorization: `Bearer ${accessToken}`,
+    "Content-Type": "application/json",
+    "User-Agent": "google-api-nodejs-client/9.15.1",
+    "X-Goog-Api-Client": "gl-node/22.17.0"
+  };
+  onProgress?.("Checking for existing Cloud Code Assist project...");
+  const loadResponse = await fetch(`${CODE_ASSIST_ENDPOINT}/v1internal:loadCodeAssist`, {
+    method: "POST",
+    headers,
+    body: JSON.stringify({
+      cloudaicompanionProject: envProjectId,
+      metadata: {
+        ideType: "IDE_UNSPECIFIED",
+        platform: "PLATFORM_UNSPECIFIED",
+        pluginType: "GEMINI",
+        duetProject: envProjectId
+      }
+    })
+  });
+  let data;
+  if (!loadResponse.ok) {
+    let errorPayload;
+    try {
+      errorPayload = await loadResponse.clone().json();
+    } catch {
+      errorPayload = void 0;
+    }
+    if (isVpcScAffectedUser(errorPayload)) {
+      data = { currentTier: { id: TIER_STANDARD } };
+    } else {
+      const errorText = await loadResponse.text();
+      throw new Error(`loadCodeAssist failed: ${loadResponse.status} ${loadResponse.statusText}: ${errorText}`);
+    }
+  } else {
+    data = await loadResponse.json();
+  }
+  if (data.currentTier) {
+    if (data.cloudaicompanionProject) {
+      return data.cloudaicompanionProject;
+    }
+    if (envProjectId) {
+      return envProjectId;
+    }
+    throw new Error("This account requires setting the GOOGLE_CLOUD_PROJECT or GOOGLE_CLOUD_PROJECT_ID environment variable. See https://goo.gle/gemini-cli-auth-docs#workspace-gca");
+  }
+  const tier = getDefaultTier(data.allowedTiers);
+  const tierId = tier?.id ?? TIER_FREE;
+  if (tierId !== TIER_FREE && !envProjectId) {
+    throw new Error("This account requires setting the GOOGLE_CLOUD_PROJECT or GOOGLE_CLOUD_PROJECT_ID environment variable. See https://goo.gle/gemini-cli-auth-docs#workspace-gca");
+  }
+  onProgress?.("Provisioning Cloud Code Assist project (this may take a moment)...");
+  const onboardBody = {
+    tierId,
+    metadata: {
+      ideType: "IDE_UNSPECIFIED",
+      platform: "PLATFORM_UNSPECIFIED",
+      pluginType: "GEMINI"
+    }
+  };
+  if (tierId !== TIER_FREE && envProjectId) {
+    onboardBody.cloudaicompanionProject = envProjectId;
+    onboardBody.metadata.duetProject = envProjectId;
+  }
+  const onboardResponse = await fetch(`${CODE_ASSIST_ENDPOINT}/v1internal:onboardUser`, {
+    method: "POST",
+    headers,
+    body: JSON.stringify(onboardBody)
+  });
+  if (!onboardResponse.ok) {
+    const errorText = await onboardResponse.text();
+    throw new Error(`onboardUser failed: ${onboardResponse.status} ${onboardResponse.statusText}: ${errorText}`);
+  }
+  let lroData = await onboardResponse.json();
+  if (!lroData.done && lroData.name) {
+    lroData = await pollOperation(lroData.name, headers, onProgress);
+  }
+  const projectId = lroData.response?.cloudaicompanionProject?.id;
+  if (projectId) {
+    return projectId;
+  }
+  if (envProjectId) {
+    return envProjectId;
+  }
+  throw new Error("Could not discover or provision a Google Cloud project. Try setting the GOOGLE_CLOUD_PROJECT or GOOGLE_CLOUD_PROJECT_ID environment variable. See https://goo.gle/gemini-cli-auth-docs#workspace-gca");
+}
+async function getUserEmail(accessToken) {
+  try {
+    const response = await fetch("https://www.googleapis.com/oauth2/v1/userinfo?alt=json", {
+      headers: {
+        Authorization: `Bearer ${accessToken}`
+      }
+    });
+    if (response.ok) {
+      const data = await response.json();
+      return data.email;
+    }
+  } catch {
+  }
+  return void 0;
+}
+async function refreshGoogleCloudToken(refreshToken, projectId) {
+  const response = await fetch(TOKEN_URL, {
+    method: "POST",
+    headers: { "Content-Type": "application/x-www-form-urlencoded" },
+    body: new URLSearchParams({
+      client_id: CLIENT_ID,
+      client_secret: CLIENT_SECRET,
+      refresh_token: refreshToken,
+      grant_type: "refresh_token"
+    })
+  });
+  if (!response.ok) {
+    const error = await response.text();
+    throw new Error(`Google Cloud token refresh failed: ${error}`);
+  }
+  const data = await response.json();
+  return {
+    refresh: data.refresh_token || refreshToken,
+    access: data.access_token,
+    expires: Date.now() + data.expires_in * 1e3 - 5 * 60 * 1e3,
+    projectId
+  };
+}
+async function loginGeminiCli(onAuth, onProgress, onManualCodeInput) {
+  const { verifier, challenge } = await generatePKCE();
+  onProgress?.("Starting local server for OAuth callback...");
+  const server = await startCallbackServer();
+  let code;
+  try {
+    const authParams = new URLSearchParams({
+      client_id: CLIENT_ID,
+      response_type: "code",
+      redirect_uri: REDIRECT_URI,
+      scope: SCOPES.join(" "),
+      code_challenge: challenge,
+      code_challenge_method: "S256",
+      state: verifier,
+      access_type: "offline",
+      prompt: "consent"
+    });
+    const authUrl = `${AUTH_URL}?${authParams.toString()}`;
+    onAuth({
+      url: authUrl,
+      instructions: "Complete the sign-in in your browser."
+    });
+    onProgress?.("Waiting for OAuth callback...");
+    if (onManualCodeInput) {
+      let manualInput;
+      let manualError;
+      const manualPromise = onManualCodeInput().then((input) => {
+        manualInput = input;
+        server.cancelWait();
+      }).catch((err) => {
+        manualError = err instanceof Error ? err : new Error(String(err));
+        server.cancelWait();
+      });
+      const result = await server.waitForCode();
+      if (manualError) {
+        throw manualError;
+      }
+      if (result?.code) {
+        if (result.state !== verifier) {
+          throw new Error("OAuth state mismatch - possible CSRF attack");
+        }
+        code = result.code;
+      } else if (manualInput) {
+        const parsed = parseRedirectUrl(manualInput);
+        if (parsed.state && parsed.state !== verifier) {
+          throw new Error("OAuth state mismatch - possible CSRF attack");
+        }
+        code = parsed.code;
+      }
+      if (!code) {
+        await manualPromise;
+        if (manualError) {
+          throw manualError;
+        }
+        if (manualInput) {
+          const parsed = parseRedirectUrl(manualInput);
+          if (parsed.state && parsed.state !== verifier) {
+            throw new Error("OAuth state mismatch - possible CSRF attack");
+          }
+          code = parsed.code;
+        }
+      }
+    } else {
+      const result = await server.waitForCode();
+      if (result?.code) {
+        if (result.state !== verifier) {
+          throw new Error("OAuth state mismatch - possible CSRF attack");
+        }
+        code = result.code;
+      }
+    }
+    if (!code) {
+      throw new Error("No authorization code received");
+    }
+    onProgress?.("Exchanging authorization code for tokens...");
+    const tokenResponse = await fetch(TOKEN_URL, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/x-www-form-urlencoded"
+      },
+      body: new URLSearchParams({
+        client_id: CLIENT_ID,
+        client_secret: CLIENT_SECRET,
+        code,
+        grant_type: "authorization_code",
+        redirect_uri: REDIRECT_URI,
+        code_verifier: verifier
+      })
+    });
+    if (!tokenResponse.ok) {
+      const error = await tokenResponse.text();
+      throw new Error(`Token exchange failed: ${error}`);
+    }
+    const tokenData = await tokenResponse.json();
+    if (!tokenData.refresh_token) {
+      throw new Error("No refresh token received. Please try again.");
+    }
+    onProgress?.("Getting user info...");
+    const email = await getUserEmail(tokenData.access_token);
+    const projectId = await discoverProject(tokenData.access_token, onProgress);
+    const expiresAt = Date.now() + tokenData.expires_in * 1e3 - 5 * 60 * 1e3;
+    const credentials = {
+      refresh: tokenData.refresh_token,
+      access: tokenData.access_token,
+      expires: expiresAt,
+      projectId,
+      email
+    };
+    return credentials;
+  } finally {
+    server.server.close();
+  }
+}
+const geminiCliOAuthProvider = {
+  id: "google-gemini-cli",
+  name: "Google Cloud Code Assist (Gemini CLI)",
+  usesCallbackServer: true,
+  async login(callbacks) {
+    return loginGeminiCli(callbacks.onAuth, callbacks.onProgress, callbacks.onManualCodeInput);
+  },
+  async refreshToken(credentials) {
+    const creds = credentials;
+    if (!creds.projectId) {
+      throw new Error("Google Cloud credentials missing projectId");
+    }
+    return refreshGoogleCloudToken(creds.refresh, creds.projectId);
+  },
+  getApiKey(credentials) {
+    const creds = credentials;
+    return JSON.stringify({ token: creds.access, projectId: creds.projectId });
+  }
+};
+export {
+  geminiCliOAuthProvider,
+  loginGeminiCli,
+  refreshGoogleCloudToken
+};

package/dist/node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/node_modules/@mariozechner/pi-ai/dist/utils/oauth/index.js

@@ -0,0 +1,41 @@
+import { anthropicOAuthProvider } from "./anthropic.js";
+import { loginAnthropic, refreshAnthropicToken } from "./anthropic.js";
+import { githubCopilotOAuthProvider } from "./github-copilot.js";
+import { getGitHubCopilotBaseUrl, loginGitHubCopilot, normalizeDomain, refreshGitHubCopilotToken } from "./github-copilot.js";
+import { antigravityOAuthProvider } from "./google-antigravity.js";
+import { loginAntigravity, refreshAntigravityToken } from "./google-antigravity.js";
+import { geminiCliOAuthProvider } from "./google-gemini-cli.js";
+import { loginGeminiCli, refreshGoogleCloudToken } from "./google-gemini-cli.js";
+import { openaiCodexOAuthProvider } from "./openai-codex.js";
+import { loginOpenAICodex, refreshOpenAICodexToken } from "./openai-codex.js";
+const BUILT_IN_OAUTH_PROVIDERS = [
+  anthropicOAuthProvider,
+  githubCopilotOAuthProvider,
+  geminiCliOAuthProvider,
+  antigravityOAuthProvider,
+  openaiCodexOAuthProvider
+];
+const oauthProviderRegistry = new Map(BUILT_IN_OAUTH_PROVIDERS.map((provider) => [provider.id, provider]));
+function getOAuthProviders() {
+  return Array.from(oauthProviderRegistry.values());
+}
+export {
+  anthropicOAuthProvider,
+  antigravityOAuthProvider,
+  geminiCliOAuthProvider,
+  getGitHubCopilotBaseUrl,
+  getOAuthProviders,
+  githubCopilotOAuthProvider,
+  loginAnthropic,
+  loginAntigravity,
+  loginGeminiCli,
+  loginGitHubCopilot,
+  loginOpenAICodex,
+  normalizeDomain,
+  openaiCodexOAuthProvider,
+  refreshAnthropicToken,
+  refreshAntigravityToken,
+  refreshGitHubCopilotToken,
+  refreshGoogleCloudToken,
+  refreshOpenAICodexToken
+};

package/dist/node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/node_modules/@mariozechner/pi-ai/dist/utils/oauth/oauth-page.js

@@ -0,0 +1,103 @@
+const LOGO_SVG = `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 800 800" aria-hidden="true"><path fill="#fff" fill-rule="evenodd" d="M165.29 165.29 H517.36 V400 H400 V517.36 H282.65 V634.72 H165.29 Z M282.65 282.65 V400 H400 V282.65 Z"/><path fill="#fff" d="M517.36 400 H634.72 V634.72 H517.36 Z"/></svg>`;
+function escapeHtml(value) {
+  return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&#39;");
+}
+function renderPage(options) {
+  const title = escapeHtml(options.title);
+  const heading = escapeHtml(options.heading);
+  const message = escapeHtml(options.message);
+  const details = options.details ? escapeHtml(options.details) : void 0;
+  return `<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1" />
+  <title>${title}</title>
+  <style>
+    :root {
+      --text: #fafafa;
+      --text-dim: #a1a1aa;
+      --page-bg: #09090b;
+      --font-sans: ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, "Helvetica Neue", Arial, "Noto Sans", sans-serif, "Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol", "Noto Color Emoji";
+      --font-mono: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, "Liberation Mono", "Courier New", monospace;
+    }
+    * { box-sizing: border-box; }
+    html { color-scheme: dark; }
+    body {
+      margin: 0;
+      min-height: 100vh;
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      padding: 24px;
+      background: var(--page-bg);
+      color: var(--text);
+      font-family: var(--font-sans);
+      text-align: center;
+    }
+    main {
+      width: 100%;
+      max-width: 560px;
+      display: flex;
+      flex-direction: column;
+      align-items: center;
+      justify-content: center;
+    }
+    .logo {
+      width: 72px;
+      height: 72px;
+      display: block;
+      margin-bottom: 24px;
+    }
+    h1 {
+      margin: 0 0 10px;
+      font-size: 28px;
+      line-height: 1.15;
+      font-weight: 650;
+      color: var(--text);
+    }
+    p {
+      margin: 0;
+      line-height: 1.7;
+      color: var(--text-dim);
+      font-size: 15px;
+    }
+    .details {
+      margin-top: 16px;
+      font-family: var(--font-mono);
+      font-size: 13px;
+      color: var(--text-dim);
+      white-space: pre-wrap;
+      word-break: break-word;
+    }
+  </style>
+</head>
+<body>
+  <main>
+    <div class="logo">${LOGO_SVG}</div>
+    <h1>${heading}</h1>
+    <p>${message}</p>
+    ${details ? `<div class="details">${details}</div>` : ""}
+  </main>
+</body>
+</html>`;
+}
+function oauthSuccessHtml(message) {
+  return renderPage({
+    title: "Authentication successful",
+    heading: "Authentication successful",
+    message
+  });
+}
+function oauthErrorHtml(message, details) {
+  return renderPage({
+    title: "Authentication failed",
+    heading: "Authentication failed",
+    message,
+    details
+  });
+}
+export {
+  oauthErrorHtml,
+  oauthSuccessHtml
+};