@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/models.js

@@ -0,0 +1,16 @@
+import { MODELS } from "./models.generated.js";
+const modelRegistry = /* @__PURE__ */ new Map();
+for (const [provider, models] of Object.entries(MODELS)) {
+  const providerModels = /* @__PURE__ */ new Map();
+  for (const [id, model] of Object.entries(models)) {
+    providerModels.set(id, model);
+  }
+  modelRegistry.set(provider, providerModels);
+}
+function getModels(provider) {
+  const models = modelRegistry.get(provider);
+  return models ? Array.from(models.values()) : [];
+}
+export {
+  getModels
+};

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

@@ -0,0 +1,314 @@
+import { oauthErrorHtml, oauthSuccessHtml } from "./oauth-page.js";
+import { generatePKCE } from "./pkce.js";
+let nodeApis = null;
+let nodeApisPromise = null;
+const decode = (s) => atob(s);
+const CLIENT_ID = decode("OWQxYzI1MGEtZTYxYi00NGQ5LTg4ZWQtNTk0NGQxOTYyZjVl");
+const AUTHORIZE_URL = "https://claude.ai/oauth/authorize";
+const TOKEN_URL = "https://platform.claude.com/v1/oauth/token";
+const CALLBACK_HOST = "127.0.0.1";
+const CALLBACK_PORT = 53692;
+const CALLBACK_PATH = "/callback";
+const REDIRECT_URI = `http://localhost:${CALLBACK_PORT}${CALLBACK_PATH}`;
+const SCOPES = "org:create_api_key user:profile user:inference user:sessions:claude_code user:mcp_servers user:file_upload";
+async function getNodeApis() {
+  if (nodeApis)
+    return nodeApis;
+  if (!nodeApisPromise) {
+    if (typeof process === "undefined" || !process.versions?.node && !process.versions?.bun) {
+      throw new Error("Anthropic OAuth is only available in Node.js environments");
+    }
+    nodeApisPromise = import("node:http").then((httpModule) => ({
+      createServer: httpModule.createServer
+    }));
+  }
+  nodeApis = await nodeApisPromise;
+  return nodeApis;
+}
+function parseAuthorizationInput(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 {
+  }
+  if (value.includes("#")) {
+    const [code, state] = value.split("#", 2);
+    return { code, state };
+  }
+  if (value.includes("code=")) {
+    const params = new URLSearchParams(value);
+    return {
+      code: params.get("code") ?? void 0,
+      state: params.get("state") ?? void 0
+    };
+  }
+  return { code: value };
+}
+function formatErrorDetails(error) {
+  if (error instanceof Error) {
+    const details = [`${error.name}: ${error.message}`];
+    const errorWithCode = error;
+    if (errorWithCode.code)
+      details.push(`code=${errorWithCode.code}`);
+    if (typeof errorWithCode.errno !== "undefined")
+      details.push(`errno=${String(errorWithCode.errno)}`);
+    if (typeof error.cause !== "undefined") {
+      details.push(`cause=${formatErrorDetails(error.cause)}`);
+    }
+    if (error.stack) {
+      details.push(`stack=${error.stack}`);
+    }
+    return details.join("; ");
+  }
+  return String(error);
+}
+async function startCallbackServer(expectedState) {
+  const { createServer } = await getNodeApis();
+  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) => {
+      try {
+        const url = new URL(req.url || "", "http://localhost");
+        if (url.pathname !== CALLBACK_PATH) {
+          res.writeHead(404, { "Content-Type": "text/html; charset=utf-8" });
+          res.end(oauthErrorHtml("Callback route not found."));
+          return;
+        }
+        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("Anthropic authentication did not complete.", `Error: ${error}`));
+          return;
+        }
+        if (!code || !state) {
+          res.writeHead(400, { "Content-Type": "text/html; charset=utf-8" });
+          res.end(oauthErrorHtml("Missing code or state parameter."));
+          return;
+        }
+        if (state !== expectedState) {
+          res.writeHead(400, { "Content-Type": "text/html; charset=utf-8" });
+          res.end(oauthErrorHtml("State mismatch."));
+          return;
+        }
+        res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
+        res.end(oauthSuccessHtml("Anthropic authentication completed. You can close this window."));
+        settleWait?.({ code, state });
+      } catch {
+        res.writeHead(500, { "Content-Type": "text/plain; charset=utf-8" });
+        res.end("Internal error");
+      }
+    });
+    server.on("error", (err) => {
+      reject(err);
+    });
+    server.listen(CALLBACK_PORT, CALLBACK_HOST, () => {
+      resolve({
+        server,
+        redirectUri: REDIRECT_URI,
+        cancelWait: () => {
+          settleWait?.(null);
+        },
+        waitForCode: () => waitForCodePromise
+      });
+    });
+  });
+}
+async function postJson(url, body) {
+  const response = await fetch(url, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Accept: "application/json"
+    },
+    body: JSON.stringify(body),
+    signal: AbortSignal.timeout(3e4)
+  });
+  const responseBody = await response.text();
+  if (!response.ok) {
+    throw new Error(`HTTP request failed. status=${response.status}; url=${url}; body=${responseBody}`);
+  }
+  return responseBody;
+}
+async function exchangeAuthorizationCode(code, state, verifier, redirectUri) {
+  let responseBody;
+  try {
+    responseBody = await postJson(TOKEN_URL, {
+      grant_type: "authorization_code",
+      client_id: CLIENT_ID,
+      code,
+      state,
+      redirect_uri: redirectUri,
+      code_verifier: verifier
+    });
+  } catch (error) {
+    throw new Error(`Token exchange request failed. url=${TOKEN_URL}; redirect_uri=${redirectUri}; response_type=authorization_code; details=${formatErrorDetails(error)}`);
+  }
+  let tokenData;
+  try {
+    tokenData = JSON.parse(responseBody);
+  } catch (error) {
+    throw new Error(`Token exchange returned invalid JSON. url=${TOKEN_URL}; body=${responseBody}; details=${formatErrorDetails(error)}`);
+  }
+  return {
+    refresh: tokenData.refresh_token,
+    access: tokenData.access_token,
+    expires: Date.now() + tokenData.expires_in * 1e3 - 5 * 60 * 1e3
+  };
+}
+async function loginAnthropic(options) {
+  const { verifier, challenge } = await generatePKCE();
+  const server = await startCallbackServer(verifier);
+  let code;
+  let state;
+  let redirectUriForExchange = REDIRECT_URI;
+  try {
+    const authParams = new URLSearchParams({
+      code: "true",
+      client_id: CLIENT_ID,
+      response_type: "code",
+      redirect_uri: REDIRECT_URI,
+      scope: SCOPES,
+      code_challenge: challenge,
+      code_challenge_method: "S256",
+      state: verifier
+    });
+    options.onAuth({
+      url: `${AUTHORIZE_URL}?${authParams.toString()}`,
+      instructions: "Complete login in your browser. If the browser is on another machine, paste the final redirect URL here."
+    });
+    if (options.onManualCodeInput) {
+      let manualInput;
+      let manualError;
+      const manualPromise = options.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) {
+        code = result.code;
+        state = result.state;
+        redirectUriForExchange = REDIRECT_URI;
+      } else if (manualInput) {
+        const parsed = parseAuthorizationInput(manualInput);
+        if (parsed.state && parsed.state !== verifier) {
+          throw new Error("OAuth state mismatch");
+        }
+        code = parsed.code;
+        state = parsed.state ?? verifier;
+      }
+      if (!code) {
+        await manualPromise;
+        if (manualError) {
+          throw manualError;
+        }
+        if (manualInput) {
+          const parsed = parseAuthorizationInput(manualInput);
+          if (parsed.state && parsed.state !== verifier) {
+            throw new Error("OAuth state mismatch");
+          }
+          code = parsed.code;
+          state = parsed.state ?? verifier;
+        }
+      }
+    } else {
+      const result = await server.waitForCode();
+      if (result?.code) {
+        code = result.code;
+        state = result.state;
+        redirectUriForExchange = REDIRECT_URI;
+      }
+    }
+    if (!code) {
+      const input = await options.onPrompt({
+        message: "Paste the authorization code or full redirect URL:",
+        placeholder: REDIRECT_URI
+      });
+      const parsed = parseAuthorizationInput(input);
+      if (parsed.state && parsed.state !== verifier) {
+        throw new Error("OAuth state mismatch");
+      }
+      code = parsed.code;
+      state = parsed.state ?? verifier;
+    }
+    if (!code) {
+      throw new Error("Missing authorization code");
+    }
+    if (!state) {
+      throw new Error("Missing OAuth state");
+    }
+    options.onProgress?.("Exchanging authorization code for tokens...");
+    return exchangeAuthorizationCode(code, state, verifier, redirectUriForExchange);
+  } finally {
+    server.server.close();
+  }
+}
+async function refreshAnthropicToken(refreshToken) {
+  let responseBody;
+  try {
+    responseBody = await postJson(TOKEN_URL, {
+      grant_type: "refresh_token",
+      client_id: CLIENT_ID,
+      refresh_token: refreshToken
+    });
+  } catch (error) {
+    throw new Error(`Anthropic token refresh request failed. url=${TOKEN_URL}; details=${formatErrorDetails(error)}`);
+  }
+  let data;
+  try {
+    data = JSON.parse(responseBody);
+  } catch (error) {
+    throw new Error(`Anthropic token refresh returned invalid JSON. url=${TOKEN_URL}; body=${responseBody}; details=${formatErrorDetails(error)}`);
+  }
+  return {
+    refresh: data.refresh_token,
+    access: data.access_token,
+    expires: Date.now() + data.expires_in * 1e3 - 5 * 60 * 1e3
+  };
+}
+const anthropicOAuthProvider = {
+  id: "anthropic",
+  name: "Anthropic (Claude Pro/Max)",
+  usesCallbackServer: true,
+  async login(callbacks) {
+    return loginAnthropic({
+      onAuth: callbacks.onAuth,
+      onPrompt: callbacks.onPrompt,
+      onProgress: callbacks.onProgress,
+      onManualCodeInput: callbacks.onManualCodeInput
+    });
+  },
+  async refreshToken(credentials) {
+    return refreshAnthropicToken(credentials.refresh);
+  },
+  getApiKey(credentials) {
+    return credentials.access;
+  }
+};
+export {
+  anthropicOAuthProvider,
+  loginAnthropic,
+  refreshAnthropicToken
+};

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

@@ -0,0 +1,256 @@
+import { getModels } from "../../models.js";
+const decode = (s) => atob(s);
+const CLIENT_ID = decode("SXYxLmI1MDdhMDhjODdlY2ZlOTg=");
+const COPILOT_HEADERS = {
+  "User-Agent": "GitHubCopilotChat/0.35.0",
+  "Editor-Version": "vscode/1.107.0",
+  "Editor-Plugin-Version": "copilot-chat/0.35.0",
+  "Copilot-Integration-Id": "vscode-chat"
+};
+const INITIAL_POLL_INTERVAL_MULTIPLIER = 1.2;
+const SLOW_DOWN_POLL_INTERVAL_MULTIPLIER = 1.4;
+function normalizeDomain(input) {
+  const trimmed = input.trim();
+  if (!trimmed)
+    return null;
+  try {
+    const url = trimmed.includes("://") ? new URL(trimmed) : new URL(`https://${trimmed}`);
+    return url.hostname;
+  } catch {
+    return null;
+  }
+}
+function getUrls(domain) {
+  return {
+    deviceCodeUrl: `https://${domain}/login/device/code`,
+    accessTokenUrl: `https://${domain}/login/oauth/access_token`,
+    copilotTokenUrl: `https://api.${domain}/copilot_internal/v2/token`
+  };
+}
+function getBaseUrlFromToken(token) {
+  const match = token.match(/proxy-ep=([^;]+)/);
+  if (!match)
+    return null;
+  const proxyHost = match[1];
+  const apiHost = proxyHost.replace(/^proxy\./, "api.");
+  return `https://${apiHost}`;
+}
+function getGitHubCopilotBaseUrl(token, enterpriseDomain) {
+  if (token) {
+    const urlFromToken = getBaseUrlFromToken(token);
+    if (urlFromToken)
+      return urlFromToken;
+  }
+  if (enterpriseDomain)
+    return `https://copilot-api.${enterpriseDomain}`;
+  return "https://api.individual.githubcopilot.com";
+}
+async function fetchJson(url, init) {
+  const response = await fetch(url, init);
+  if (!response.ok) {
+    const text = await response.text();
+    throw new Error(`${response.status} ${response.statusText}: ${text}`);
+  }
+  return response.json();
+}
+async function startDeviceFlow(domain) {
+  const urls = getUrls(domain);
+  const data = await fetchJson(urls.deviceCodeUrl, {
+    method: "POST",
+    headers: {
+      Accept: "application/json",
+      "Content-Type": "application/x-www-form-urlencoded",
+      "User-Agent": "GitHubCopilotChat/0.35.0"
+    },
+    body: new URLSearchParams({
+      client_id: CLIENT_ID,
+      scope: "read:user"
+    })
+  });
+  if (!data || typeof data !== "object") {
+    throw new Error("Invalid device code response");
+  }
+  const deviceCode = data.device_code;
+  const userCode = data.user_code;
+  const verificationUri = data.verification_uri;
+  const interval = data.interval;
+  const expiresIn = data.expires_in;
+  if (typeof deviceCode !== "string" || typeof userCode !== "string" || typeof verificationUri !== "string" || typeof interval !== "number" || typeof expiresIn !== "number") {
+    throw new Error("Invalid device code response fields");
+  }
+  return {
+    device_code: deviceCode,
+    user_code: userCode,
+    verification_uri: verificationUri,
+    interval,
+    expires_in: expiresIn
+  };
+}
+function abortableSleep(ms, signal) {
+  return new Promise((resolve, reject) => {
+    if (signal?.aborted) {
+      reject(new Error("Login cancelled"));
+      return;
+    }
+    const timeout = setTimeout(resolve, ms);
+    signal?.addEventListener("abort", () => {
+      clearTimeout(timeout);
+      reject(new Error("Login cancelled"));
+    }, { once: true });
+  });
+}
+async function pollForGitHubAccessToken(domain, deviceCode, intervalSeconds, expiresIn, signal) {
+  const urls = getUrls(domain);
+  const deadline = Date.now() + expiresIn * 1e3;
+  let intervalMs = Math.max(1e3, Math.floor(intervalSeconds * 1e3));
+  let intervalMultiplier = INITIAL_POLL_INTERVAL_MULTIPLIER;
+  let slowDownResponses = 0;
+  while (Date.now() < deadline) {
+    if (signal?.aborted) {
+      throw new Error("Login cancelled");
+    }
+    const remainingMs = deadline - Date.now();
+    const waitMs = Math.min(Math.ceil(intervalMs * intervalMultiplier), remainingMs);
+    await abortableSleep(waitMs, signal);
+    const raw = await fetchJson(urls.accessTokenUrl, {
+      method: "POST",
+      headers: {
+        Accept: "application/json",
+        "Content-Type": "application/x-www-form-urlencoded",
+        "User-Agent": "GitHubCopilotChat/0.35.0"
+      },
+      body: new URLSearchParams({
+        client_id: CLIENT_ID,
+        device_code: deviceCode,
+        grant_type: "urn:ietf:params:oauth:grant-type:device_code"
+      })
+    });
+    if (raw && typeof raw === "object" && typeof raw.access_token === "string") {
+      return raw.access_token;
+    }
+    if (raw && typeof raw === "object" && typeof raw.error === "string") {
+      const { error, error_description: description, interval } = raw;
+      if (error === "authorization_pending") {
+        continue;
+      }
+      if (error === "slow_down") {
+        slowDownResponses += 1;
+        intervalMs = typeof interval === "number" && interval > 0 ? interval * 1e3 : Math.max(1e3, intervalMs + 5e3);
+        intervalMultiplier = SLOW_DOWN_POLL_INTERVAL_MULTIPLIER;
+        continue;
+      }
+      const descriptionSuffix = description ? `: ${description}` : "";
+      throw new Error(`Device flow failed: ${error}${descriptionSuffix}`);
+    }
+  }
+  if (slowDownResponses > 0) {
+    throw new Error("Device flow timed out after one or more slow_down responses. This is often caused by clock drift in WSL or VM environments. Please sync or restart the VM clock and try again.");
+  }
+  throw new Error("Device flow timed out");
+}
+async function refreshGitHubCopilotToken(refreshToken, enterpriseDomain) {
+  const domain = enterpriseDomain || "github.com";
+  const urls = getUrls(domain);
+  const raw = await fetchJson(urls.copilotTokenUrl, {
+    headers: {
+      Accept: "application/json",
+      Authorization: `Bearer ${refreshToken}`,
+      ...COPILOT_HEADERS
+    }
+  });
+  if (!raw || typeof raw !== "object") {
+    throw new Error("Invalid Copilot token response");
+  }
+  const token = raw.token;
+  const expiresAt = raw.expires_at;
+  if (typeof token !== "string" || typeof expiresAt !== "number") {
+    throw new Error("Invalid Copilot token response fields");
+  }
+  return {
+    refresh: refreshToken,
+    access: token,
+    expires: expiresAt * 1e3 - 5 * 60 * 1e3,
+    enterpriseUrl: enterpriseDomain
+  };
+}
+async function enableGitHubCopilotModel(token, modelId, enterpriseDomain) {
+  const baseUrl = getGitHubCopilotBaseUrl(token, enterpriseDomain);
+  const url = `${baseUrl}/models/${modelId}/policy`;
+  try {
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${token}`,
+        ...COPILOT_HEADERS,
+        "openai-intent": "chat-policy",
+        "x-interaction-type": "chat-policy"
+      },
+      body: JSON.stringify({ state: "enabled" })
+    });
+    return response.ok;
+  } catch {
+    return false;
+  }
+}
+async function enableAllGitHubCopilotModels(token, enterpriseDomain, onProgress) {
+  const models = getModels("github-copilot");
+  await Promise.all(models.map(async (model) => {
+    await enableGitHubCopilotModel(token, model.id, enterpriseDomain);
+  }));
+}
+async function loginGitHubCopilot(options) {
+  const input = await options.onPrompt({
+    message: "GitHub Enterprise URL/domain (blank for github.com)",
+    placeholder: "company.ghe.com",
+    allowEmpty: true
+  });
+  if (options.signal?.aborted) {
+    throw new Error("Login cancelled");
+  }
+  const trimmed = input.trim();
+  const enterpriseDomain = normalizeDomain(input);
+  if (trimmed && !enterpriseDomain) {
+    throw new Error("Invalid GitHub Enterprise URL/domain");
+  }
+  const domain = enterpriseDomain || "github.com";
+  const device = await startDeviceFlow(domain);
+  options.onAuth(device.verification_uri, `Enter code: ${device.user_code}`);
+  const githubAccessToken = await pollForGitHubAccessToken(domain, device.device_code, device.interval, device.expires_in, options.signal);
+  const credentials = await refreshGitHubCopilotToken(githubAccessToken, enterpriseDomain ?? void 0);
+  options.onProgress?.("Enabling models...");
+  await enableAllGitHubCopilotModels(credentials.access, enterpriseDomain ?? void 0);
+  return credentials;
+}
+const githubCopilotOAuthProvider = {
+  id: "github-copilot",
+  name: "GitHub Copilot",
+  async login(callbacks) {
+    return loginGitHubCopilot({
+      onAuth: (url, instructions) => callbacks.onAuth({ url, instructions }),
+      onPrompt: callbacks.onPrompt,
+      onProgress: callbacks.onProgress,
+      signal: callbacks.signal
+    });
+  },
+  async refreshToken(credentials) {
+    const creds = credentials;
+    return refreshGitHubCopilotToken(creds.refresh, creds.enterpriseUrl);
+  },
+  getApiKey(credentials) {
+    return credentials.access;
+  },
+  modifyModels(models, credentials) {
+    const creds = credentials;
+    const domain = creds.enterpriseUrl ? normalizeDomain(creds.enterpriseUrl) ?? void 0 : void 0;
+    const baseUrl = getGitHubCopilotBaseUrl(creds.access, domain);
+    return models.map((m) => m.provider === "github-copilot" ? { ...m, baseUrl } : m);
+  }
+};
+export {
+  getGitHubCopilotBaseUrl,
+  githubCopilotOAuthProvider,
+  loginGitHubCopilot,
+  normalizeDomain,
+  refreshGitHubCopilotToken
+};