@nyte-ai/ai 0.0.0-stage → 0.0.18

package/dist/chunks/account-limits-cache-4fn5w63p.js

@@ -0,0 +1,295 @@
+import {
+  getProviderEnvValue2
+} from "./account-limits-cache-b23sbrke.js";
+import {
+  OAuthTokenResponseSchema2
+} from "./account-limits-cache-b0x2sfya.js";
+import {
+  parseAuthorizationInput2
+} from "./account-limits-cache-d1ypzqzp.js";
+import {
+  oauthSuccessHtml2,
+  oauthErrorHtml2
+} from "./account-limits-cache-8vzx8k6r.js";
+import {
+  registerOAuthFlow2
+} from "./account-limits-cache-v4n30az2.js";
+import {
+  generatePKCE2
+} from "./account-limits-cache-tc38g0ca.js";
+
+// src/auth/oauth/anthropic.ts
+import { createServer } from "node:http";
+import { Value } from "typebox/value";
+var decode = (s) => atob(s);
+var CLIENT_ID = decode("OWQxYzI1MGEtZTYxYi00NGQ5LTg4ZWQtNTk0NGQxOTYyZjVl");
+var AUTHORIZE_URL = "https://claude.ai/oauth/authorize";
+var TOKEN_URL = "https://platform.claude.com/v1/oauth/token";
+var CALLBACK_HOST = getProviderEnvValue2("NYTE_OAUTH_CALLBACK_HOST") || "127.0.0.1";
+var CALLBACK_PORT = 53692;
+var CALLBACK_PATH = "/callback";
+var REDIRECT_URI = `http://localhost:${CALLBACK_PORT}${CALLBACK_PATH}`;
+var COPY_CODE_REDIRECT_URI = "https://platform.claude.com/oauth/code/callback";
+var SCOPES = "org:create_api_key user:profile user:inference user:sessions:claude_code user:mcp_servers user:file_upload";
+function formatErrorDetails(cause) {
+  if (cause instanceof Error) {
+    const details = [`${cause.name}: ${cause.message}`];
+    if ("code" in cause && cause.code)
+      details.push(`code=${String(cause.code)}`);
+    if ("errno" in cause && cause.errno !== undefined)
+      details.push(`errno=${String(cause.errno)}`);
+    if (cause.cause !== undefined) {
+      details.push(`cause=${formatErrorDetails(cause.cause)}`);
+    }
+    if (cause.stack) {
+      details.push(`stack=${cause.stack}`);
+    }
+    return details.join("; ");
+  }
+  return String(cause);
+}
+async function startCallbackServer(expectedState) {
+  return new Promise((resolve, reject) => {
+    let settleWait;
+    const waitForCodePromise = new Promise((resolveWait, rejectWait) => {
+      let settled = false;
+      settleWait = (value) => {
+        if (settled)
+          return;
+        settled = true;
+        if (value instanceof Error)
+          rejectWait(value);
+        else
+          resolveWait(value);
+      };
+    });
+    waitForCodePromise.catch(() => {
+      return;
+    });
+    const server = createServer((req, res) => {
+      try {
+        const url = new URL(req.url || "", "http://localhost");
+        if (req.method !== "GET" || url.pathname !== CALLBACK_PATH) {
+          res.writeHead(404, { "Content-Type": "text/html; charset=utf-8" });
+          res.end(oauthErrorHtml2("Nyte is not listening on this path. Run the login command again to retry."));
+          return;
+        }
+        const code = url.searchParams.get("code");
+        const state = url.searchParams.get("state");
+        const error = url.searchParams.get("error");
+        if (state !== expectedState) {
+          res.writeHead(400, { "Content-Type": "text/html; charset=utf-8" });
+          res.end(oauthErrorHtml2("The callback's state did not match this login attempt, so Nyte ignored it."));
+          return;
+        }
+        if (error) {
+          const description = url.searchParams.get("error_description") ?? error;
+          res.writeHead(400, { "Content-Type": "text/html; charset=utf-8" });
+          res.end(oauthErrorHtml2("Anthropic sent back an error instead of a code. Run the login command again to retry.", `Error: ${description}`));
+          settleWait?.(new Error(`Anthropic authorization failed: ${description}`));
+          return;
+        }
+        if (!code) {
+          res.writeHead(400, { "Content-Type": "text/html; charset=utf-8" });
+          res.end(oauthErrorHtml2("The callback arrived without a code, so Nyte could not finish sign-in."));
+          return;
+        }
+        res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
+        res.end(oauthSuccessHtml2({ provider: "Anthropic" }));
+        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);
+        },
+        failWait: (error) => {
+          settleWait?.(error);
+        },
+        waitForCode: () => waitForCodePromise
+      });
+    });
+  });
+}
+async function postJson(url, body, signal) {
+  const response = await fetch(url, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Accept: "application/json"
+    },
+    body: JSON.stringify(body),
+    signal: AbortSignal.any([signal, AbortSignal.timeout(30000)])
+  });
+  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, signal) {
+  let responseBody;
+  try {
+    responseBody = await postJson(TOKEN_URL, {
+      grant_type: "authorization_code",
+      client_id: CLIENT_ID,
+      code,
+      state,
+      redirect_uri: redirectUri,
+      code_verifier: verifier
+    }, signal);
+  } 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)}`);
+  }
+  if (!Value.Check(OAuthTokenResponseSchema2, tokenData)) {
+    throw new Error(`Token exchange returned an incomplete token response. url=${TOKEN_URL}`);
+  }
+  return {
+    type: "oauth",
+    refresh: tokenData.refresh_token,
+    access: tokenData.access_token,
+    expires: Date.now() + tokenData.expires_in * 1000 - 5 * 60 * 1000
+  };
+}
+async function loginAnthropic(interaction, method) {
+  const { verifier, challenge } = await generatePKCE2();
+  const redirectUri = method === "copy_code" ? COPY_CODE_REDIRECT_URI : REDIRECT_URI;
+  const server = method === "browser" ? await startCallbackServer(verifier).catch(() => {
+    return;
+  }) : undefined;
+  const manualAbort = new AbortController;
+  const onAbort = () => {
+    server?.failWait(new Error("Login cancelled"));
+    manualAbort.abort();
+    server?.server.close();
+  };
+  interaction.signal.addEventListener("abort", onAbort, { once: true });
+  if (interaction.signal.aborted)
+    onAbort();
+  let manualInput;
+  let manualError;
+  try {
+    if (interaction.signal.aborted)
+      throw new Error("Login cancelled");
+    const authParams = new URLSearchParams({
+      code: "true",
+      client_id: CLIENT_ID,
+      response_type: "code",
+      redirect_uri: redirectUri,
+      scope: SCOPES,
+      code_challenge: challenge,
+      code_challenge_method: "S256",
+      state: verifier
+    });
+    interaction.notify({
+      type: "auth_url",
+      url: `${AUTHORIZE_URL}?${authParams.toString()}`,
+      instructions: method === "copy_code" ? "Complete login in your browser, then copy the code Anthropic shows and paste it here." : "Complete login in your browser. If the browser is on another machine, paste the final redirect URL here."
+    });
+    const manualPromise = interaction.prompt({
+      type: "manual_code",
+      message: method === "copy_code" ? "Paste the code Anthropic shows after you sign in:" : "Complete login in your browser, or paste the authorization code / redirect URL here:",
+      placeholder: method === "copy_code" ? "code#state" : REDIRECT_URI,
+      signal: manualAbort.signal
+    }).then((input) => {
+      manualInput = input;
+      server?.cancelWait();
+    }).catch((error) => {
+      manualError = error instanceof Error ? error : new Error(String(error));
+      server?.cancelWait();
+    });
+    const result = await server?.waitForCode();
+    if (!result)
+      await manualPromise;
+    if (interaction.signal.aborted)
+      throw new Error("Login cancelled");
+    if (manualError)
+      throw manualError;
+    const parsed = result ?? parseAuthorizationInput2(manualInput ?? "");
+    if (parsed.state && parsed.state !== verifier)
+      throw new Error("OAuth state mismatch");
+    if (!parsed.code)
+      throw new Error("Missing authorization code");
+    interaction.notify({
+      type: "progress",
+      message: "Exchanging authorization code for tokens..."
+    });
+    return exchangeAuthorizationCode(parsed.code, parsed.state ?? verifier, verifier, redirectUri, interaction.signal);
+  } finally {
+    interaction.signal.removeEventListener("abort", onAbort);
+    manualAbort.abort();
+    server?.server.close();
+  }
+}
+async function refreshAnthropicToken(refreshToken, signal) {
+  let responseBody;
+  try {
+    responseBody = await postJson(TOKEN_URL, {
+      grant_type: "refresh_token",
+      client_id: CLIENT_ID,
+      refresh_token: refreshToken
+    }, signal);
+  } 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)}`);
+  }
+  if (!Value.Check(OAuthTokenResponseSchema2, data)) {
+    throw new Error(`Anthropic token refresh returned an incomplete token response. url=${TOKEN_URL}`);
+  }
+  return {
+    type: "oauth",
+    refresh: data.refresh_token,
+    access: data.access_token,
+    expires: Date.now() + data.expires_in * 1000 - 5 * 60 * 1000
+  };
+}
+var anthropicOAuth2 = {
+  name: "Anthropic (Claude Pro/Max)",
+  isSubscription: true,
+  async login(interaction) {
+    if (interaction.signal.aborted)
+      throw new Error("Login cancelled");
+    const method = interaction.browser === "host" ? "browser" : interaction.browser === "elsewhere" ? "copy_code" : await interaction.prompt({
+      type: "select",
+      message: "Select Anthropic login method:",
+      options: [
+        { id: "browser", label: "Browser login (default)" },
+        { id: "copy_code", label: "Copy code login (headless)" }
+      ],
+      signal: interaction.signal
+    });
+    if (interaction.signal.aborted)
+      throw new Error("Login cancelled");
+    if (method !== "browser" && method !== "copy_code") {
+      throw new Error(`Unknown Anthropic login method: ${method}`);
+    }
+    return loginAnthropic(interaction, method);
+  },
+  refresh: (credential, signal) => refreshAnthropicToken(credential.refresh, signal),
+  async toAuth(credential) {
+    return { apiKey: credential.access };
+  }
+};
+registerOAuthFlow2("anthropic", anthropicOAuth2);
+
+export { anthropicOAuth2 };

package/dist/chunks/account-limits-cache-4hptgd2h.js

@@ -0,0 +1,49 @@
+import {
+  sleep2
+} from "./account-limits-cache-j2bt392s.js";
+
+// src/auth/oauth/device-code.ts
+var CANCEL_MESSAGE = "Login cancelled";
+var TIMEOUT_MESSAGE = "Device flow timed out";
+var SLOW_DOWN_TIMEOUT_MESSAGE = "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.";
+var MINIMUM_INTERVAL_MS = 1000;
+var DEFAULT_POLL_INTERVAL_SECONDS = 5;
+var SLOW_DOWN_INTERVAL_INCREMENT_MS = 5000;
+function abortableSleep3(ms, signal, cancelMessage) {
+  return sleep2(ms, signal, () => new Error(cancelMessage));
+}
+async function pollOAuthDeviceCodeFlow2(options) {
+  const deadline = options.expiresInSeconds !== undefined ? Date.now() + options.expiresInSeconds * 1000 : Number.POSITIVE_INFINITY;
+  let intervalMs = Math.max(MINIMUM_INTERVAL_MS, Math.floor((options.intervalSeconds ?? DEFAULT_POLL_INTERVAL_SECONDS) * 1000));
+  let slowDownResponses = 0;
+  if (options.waitBeforeFirstPoll) {
+    const remainingMs = deadline - Date.now();
+    if (remainingMs > 0) {
+      await abortableSleep3(Math.min(intervalMs, remainingMs), options.signal, CANCEL_MESSAGE);
+    }
+  }
+  while (Date.now() < deadline) {
+    if (options.signal.aborted) {
+      throw new Error(CANCEL_MESSAGE);
+    }
+    const result = await options.poll();
+    if (result.status === "complete") {
+      return result.value;
+    }
+    if (result.status === "failed") {
+      throw new Error(result.message);
+    }
+    if (result.status === "slow_down") {
+      slowDownResponses += 1;
+      intervalMs = result.intervalSeconds !== undefined && Number.isFinite(result.intervalSeconds) && result.intervalSeconds > 0 ? Math.max(MINIMUM_INTERVAL_MS, Math.floor(result.intervalSeconds * 1000)) : Math.max(MINIMUM_INTERVAL_MS, intervalMs + SLOW_DOWN_INTERVAL_INCREMENT_MS);
+    }
+    const remainingMs = deadline - Date.now();
+    if (remainingMs <= 0) {
+      break;
+    }
+    await abortableSleep3(Math.min(intervalMs, remainingMs), options.signal, CANCEL_MESSAGE);
+  }
+  throw new Error(slowDownResponses > 0 ? SLOW_DOWN_TIMEOUT_MESSAGE : TIMEOUT_MESSAGE);
+}
+
+export { abortableSleep3, pollOAuthDeviceCodeFlow2 };