@ai-sdk/harness-claude-code 1.0.110 → 1.0.112

package/CHANGELOG.md

@@ -1,5 +1,26 @@
 # @ai-sdk/harness-claude-code
 
+## 1.0.112
+
+### Patch Changes
+
+- cdc12a1: feat(harness): add support for using adapter-native subscriptions where available
+- Updated dependencies [4d1bf28]
+- Updated dependencies [cdc12a1]
+- Updated dependencies [d70a334]
+- Updated dependencies [81ba84c]
+- Updated dependencies [813bb36]
+- Updated dependencies [c43e4b7]
+  - @ai-sdk/harness@1.0.108
+  - @ai-sdk/provider-utils@5.0.40
+
+## 1.0.111
+
+### Patch Changes
+
+- @ai-sdk/harness@1.0.107
+- @ai-sdk/provider-utils@5.0.39
+
 ## 1.0.110
 
 ### Patch Changes

package/dist/index.js

@@ -28,7 +28,7 @@ import {
   writeSkills
 } from "@ai-sdk/harness/utils";
 import {
-  safeParseJSON,
+  safeParseJSON as safeParseJSON2,
   tool
 } from "@ai-sdk/provider-utils";
 import { WebSocket } from "ws";
@@ -86,7 +86,8 @@ import {
 var CLAUDE_CODE_CREDENTIAL_ENVIRONMENT_VARIABLES = [
   "AI_GATEWAY_API_KEY",
   "ANTHROPIC_API_KEY",
-  "ANTHROPIC_AUTH_TOKEN"
+  "ANTHROPIC_AUTH_TOKEN",
+  "CLAUDE_CODE_OAUTH_TOKEN"
 ];
 function createClaudeCodeRequestTransformations({
   env: environment,
@@ -164,8 +165,10 @@ function pickAnthropic({
   const helperKey = readApiKey();
   const apiKey = processEnv.ANTHROPIC_API_KEY ?? helperKey;
   const authToken = processEnv.ANTHROPIC_AUTH_TOKEN ?? helperKey;
+  const oauthToken = processEnv.CLAUDE_CODE_OAUTH_TOKEN;
   if (apiKey) env.ANTHROPIC_API_KEY = apiKey;
   if (authToken) env.ANTHROPIC_AUTH_TOKEN = authToken;
+  if (oauthToken) env.CLAUDE_CODE_OAUTH_TOKEN = oauthToken;
   const baseUrl = processEnv.ANTHROPIC_BASE_URL;
   if (baseUrl) env.ANTHROPIC_BASE_URL = baseUrl;
   return env;
@@ -213,6 +216,184 @@ function pickGateway({
   return env;
 }
 
+// src/claude-code-subscription.ts
+import { execFileSync as execFileSync2 } from "child_process";
+import { chmod, mkdir, readFile, rename, writeFile } from "fs/promises";
+import { homedir as homedir2 } from "os";
+import { dirname, join as join2, resolve } from "path";
+import {
+  createCredentialRequestTransformation as createCredentialRequestTransformation2,
+  isAccessTokenExpiringSoon,
+  isHarnessAuthenticationEnvironment as isHarnessAuthenticationEnvironment2,
+  isMacOS,
+  readMacOSKeychainPassword,
+  refreshOAuthAccessToken,
+  shouldResolveNativeSubscription
+} from "@ai-sdk/harness/utils";
+import { isRecord, safeParseJSON } from "@ai-sdk/provider-utils";
+var CLAUDE_TOKEN_URL = "https://platform.claude.com/v1/oauth/token";
+var CLAUDE_CLIENT_ID = "9d1c250a-e61b-44d9-88ed-5944d1962f5e";
+function createClaudeCodeSubscriptionRequestTransformations({
+  env: environment,
+  sandboxEnv: sandboxEnvironment,
+  auth: authenticationMode
+}) {
+  if (environment.CLAUDE_CODE_OAUTH_TOKEN == null || sandboxEnvironment.CLAUDE_CODE_OAUTH_TOKEN == null) {
+    return [];
+  }
+  return [
+    createCredentialRequestTransformation2({
+      matchUrl: authenticationMode === "ai-gateway" ? environment.ANTHROPIC_BASE_URL : environment.ANTHROPIC_BASE_URL ?? "https://api.anthropic.com",
+      matchHeaders: {
+        Authorization: `Bearer ${sandboxEnvironment.CLAUDE_CODE_OAUTH_TOKEN}`
+      },
+      transformHeaders: {
+        Authorization: `Bearer ${environment.CLAUDE_CODE_OAUTH_TOKEN}`
+      }
+    })
+  ];
+}
+async function resolveClaudeCodeAuthentication({
+  auth,
+  processEnv = process.env,
+  options = {},
+  readSubscription = readClaudeCodeSubscription
+}) {
+  const environmentWithoutHelper = resolveClaudeCodeEnv(auth, processEnv, {
+    readApiKeyHelper: () => void 0
+  });
+  if (isHarnessAuthenticationEnvironment2(auth)) {
+    return environmentWithoutHelper;
+  }
+  if (!shouldResolveNativeSubscription({
+    auth,
+    env: environmentWithoutHelper,
+    hasDirectCredential: environmentWithoutHelper.ANTHROPIC_API_KEY != null || environmentWithoutHelper.ANTHROPIC_AUTH_TOKEN != null || environmentWithoutHelper.CLAUDE_CODE_OAUTH_TOKEN != null
+  })) {
+    return environmentWithoutHelper;
+  }
+  return await readSubscription() ?? resolveClaudeCodeEnv(auth, processEnv, options);
+}
+async function readClaudeCodeSubscription({
+  env = process.env,
+  homeDirectory = homedir2(),
+  platform = process.platform,
+  fetch
+} = {}) {
+  const configDirectory = resolve(
+    env.CLAUDE_CONFIG_DIR ?? join2(homeDirectory, ".claude")
+  );
+  const credentialPath = join2(configDirectory, ".credentials.json");
+  const stored = await readClaudeCredentialStore({
+    credentialPath,
+    homeDirectory,
+    configDirectory,
+    platform
+  });
+  if (stored == null) return void 0;
+  const oauth = getClaudeOAuthCredential({ value: stored.value });
+  if (oauth == null) return void 0;
+  const { accessToken, refreshToken, expiresAt } = oauth;
+  let resolvedAccessToken = accessToken;
+  if (isAccessTokenExpiringSoon({ expiresAt })) {
+    const refreshed = await refreshOAuthAccessToken({
+      tokenUrl: CLAUDE_TOKEN_URL,
+      clientId: CLAUDE_CLIENT_ID,
+      refreshToken,
+      requestFormat: "json",
+      ...fetch == null ? {} : { fetch }
+    });
+    resolvedAccessToken = refreshed.accessToken;
+    await stored.write({
+      ...stored.value,
+      claudeAiOauth: {
+        ...oauth,
+        accessToken: refreshed.accessToken,
+        refreshToken: refreshed.refreshToken ?? refreshToken,
+        expiresAt: refreshed.expiresAt
+      }
+    });
+  }
+  return {
+    CLAUDE_CODE_OAUTH_TOKEN: resolvedAccessToken,
+    ANTHROPIC_BASE_URL: "https://api.anthropic.com"
+  };
+}
+async function readClaudeCredentialStore({
+  credentialPath,
+  homeDirectory,
+  configDirectory,
+  platform
+}) {
+  const text = await readFile(credentialPath, "utf8").catch(() => void 0);
+  if (text != null) {
+    const value2 = await parseClaudeCredentialFile(text);
+    if (value2 != null && getClaudeOAuthCredential({ value: value2 }) != null) {
+      return {
+        value: value2,
+        write: (updated) => writeClaudeCredentialFile({ credentialPath, value: updated })
+      };
+    }
+  }
+  if (!isMacOS(platform)) return void 0;
+  if (configDirectory !== resolve(join2(homeDirectory, ".claude"))) {
+    return void 0;
+  }
+  const service = "Claude Code-credentials";
+  const keychainText = await readMacOSKeychainPassword({
+    service,
+    account: process.env.USER ?? ""
+  });
+  if (keychainText == null) return void 0;
+  const value = await parseClaudeCredentialFile(keychainText);
+  if (value == null) return void 0;
+  return {
+    value,
+    write: async (updated) => {
+      execFileSync2(
+        "/usr/bin/security",
+        [
+          "add-generic-password",
+          "-U",
+          "-s",
+          service,
+          "-a",
+          process.env.USER ?? "",
+          "-w",
+          JSON.stringify(updated)
+        ],
+        { stdio: "ignore" }
+      );
+    }
+  };
+}
+function getClaudeOAuthCredential({
+  value
+}) {
+  const oauth = value.claudeAiOauth;
+  if (!isRecord(oauth) || typeof oauth.accessToken !== "string" || typeof oauth.refreshToken !== "string" || typeof oauth.expiresAt !== "number") {
+    return void 0;
+  }
+  return oauth;
+}
+async function parseClaudeCredentialFile(text) {
+  const parsed = await safeParseJSON({ text });
+  return parsed.success && isRecord(parsed.value) ? parsed.value : void 0;
+}
+async function writeClaudeCredentialFile({
+  credentialPath,
+  value
+}) {
+  await mkdir(dirname(credentialPath), { recursive: true });
+  const temporaryPath = `${credentialPath}.${process.pid}.tmp`;
+  await writeFile(temporaryPath, `${JSON.stringify(value, null, 2)}
+`, {
+    mode: 384
+  });
+  await chmod(temporaryPath, 384);
+  await rename(temporaryPath, credentialPath);
+}
+
 // src/claude-code-bridge-protocol.ts
 import {
   harnessV1BridgeInboundCommandSchemas,
@@ -261,7 +442,7 @@ var inboundMessageSchema = z.discriminatedUnion("type", [
 ]);
 
 // src/version.ts
-var VERSION = true ? "1.0.110" : "0.0.0-test";
+var VERSION = true ? "1.0.112" : "0.0.0-test";
 
 // src/claude-code-harness.ts
 var CLAUDE_CODE_CLIENT_APP = `ai-sdk/harness-claude-code/${VERSION}`;
@@ -901,7 +1082,9 @@ function createClaudeCode(settings = {}) {
       const authenticationMode = resolveClaudeCodeAuthenticationMode(
         settings.auth
       );
-      const resolvedAuthEnvironment = resolveClaudeCodeEnv(settings.auth);
+      const resolvedAuthEnvironment = await resolveClaudeCodeAuthentication({
+        auth: settings.auth
+      });
       const claudeEnvironment = {
         ...resolvedAuthEnvironment,
         /*
@@ -928,11 +1111,17 @@ function createClaudeCode(settings = {}) {
           ...claudeEnvironment,
           ...sandboxCredentialEnvironment
         };
-        const requestTransformations = createClaudeCodeRequestTransformations({
+        const transformationSources = {
           env: claudeEnvironment,
           sandboxEnv: sandboxClaudeEnvironment,
           auth: authenticationMode
-        });
+        };
+        const requestTransformations = [
+          ...createClaudeCodeRequestTransformations(transformationSources),
+          ...createClaudeCodeSubscriptionRequestTransformations(
+            transformationSources
+          )
+        ];
         if (requestTransformations.length > 0) {
           await sandboxSession.addRequestTransformations(
             requestTransformations
@@ -1201,7 +1390,7 @@ function openWebSocketAndWaitForBridgeHello({
   getHelloTimeoutMs,
   onHello
 }) {
-  return new Promise((resolve, reject) => {
+  return new Promise((resolve2, reject) => {
     const ws = new WebSocket(endpoint.url, {
       headers: endpoint.headers == null ? void 0 : { ...endpoint.headers }
     });
@@ -1235,7 +1424,7 @@ function openWebSocketAndWaitForBridgeHello({
         reject(err);
       } else {
         cleanup();
-        resolve(ws);
+        resolve2(ws);
       }
     };
     const tryResolve = () => {
@@ -1265,7 +1454,7 @@ function openWebSocketAndWaitForBridgeHello({
     };
     const onMessage = (raw) => {
       void (async () => {
-        const parsed = await safeParseJSON({
+        const parsed = await safeParseJSON2({
           text: webSocketMessageToString(raw)
         });
         if (!parsed.success || settled) return;
@@ -1338,8 +1527,8 @@ function webSocketMessageToString(raw) {
   return String(raw);
 }
 function sleep(ms) {
-  return new Promise((resolve) => {
-    const timer = setTimeout(resolve, ms);
+  return new Promise((resolve2) => {
+    const timer = setTimeout(resolve2, ms);
     timer.unref?.();
   });
 }
@@ -1378,8 +1567,8 @@ function createSession({
   const wireTurn = (turnOpts) => {
     let pendingResolve;
     let pendingReject;
-    const done = new Promise((resolve, reject) => {
-      pendingResolve = resolve;
+    const done = new Promise((resolve2, reject) => {
+      pendingResolve = resolve2;
       pendingReject = reject;
     });
     const userMessageSubmitter = supportsUserMessageResponses() ? experimental_createBridgeUserMessageSubmitter({
@@ -1642,8 +1831,8 @@ function createSession({
           if (proc) {
             await Promise.race([
               proc.wait(),
-              new Promise((resolve) => {
-                stopTimer = setTimeout(resolve, 5e3);
+              new Promise((resolve2) => {
+                stopTimer = setTimeout(resolve2, 5e3);
                 stopTimer.unref?.();
               })
             ]);
@@ -1667,7 +1856,7 @@ function createSession({
       }
       stopped = true;
       channel.beginClose();
-      const data = channel.isClosed() ? {} : await new Promise((resolve, reject) => {
+      const data = channel.isClosed() ? {} : await new Promise((resolve2, reject) => {
         const timer = setTimeout(() => {
           unsub();
           reject(
@@ -1680,7 +1869,7 @@ function createSession({
         const unsub = channel.on("bridge-stop", (msg) => {
           clearTimeout(timer);
           unsub();
-          resolve(msg.data);
+          resolve2(msg.data);
         });
         try {
           channel.send({ type: "stop" });
@@ -1695,8 +1884,8 @@ function createSession({
         if (proc) {
           await Promise.race([
             proc.wait(),
-            new Promise((resolve) => {
-              stopTimer = setTimeout(resolve, 5e3);
+            new Promise((resolve2) => {
+              stopTimer = setTimeout(resolve2, 5e3);
               stopTimer.unref?.();
             })
           ]);