opencode-ext-connector 0.7.0 → 0.7.1

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## 0.7.1 - 2026-09-23
+
+- Restrict the `credentialAuthority` schema to a strict, deeply-frozen Claude CLI
+  object: unknown keys fail parsing, empty input normalizes to disabled defaults
+  with `leadMs: 300_000` and `retryMs: 300_000`, and only `claudeCli` is accepted
+- Strip `ANTHROPIC_API_KEY` from every Claude authority child invocation so the
+  stored OAuth login is always used regardless of any in-memory key, without
+  mutating the parent environment
+- Attempt every disposer on shutdown through `Promise.allSettled` and keep the
+  Claude authority failure as the primary error so the xAI authority, supervisor,
+  and runtime disposers still run alongside Claude while Claude stays primary
+
 ## 0.7.0 - 2026-09-23
 
 - Add the opt-in `xaiOAuth.mode: "authority" | "consumer"` package subpath

package/README.md

@@ -19,7 +19,7 @@
 
 ## Status
 
-> Independent unofficial community plugin, version **0.7.0**. Package E2E tests exercise the legacy multi-function loader with the OpenCode CLI installed in CI. `@opencode-ai/plugin@1.18.18` is the compile-time plugin API target, not a runtime pin. Source is BSD-3-Clause. This project is not affiliated with, endorsed by, sponsored by, or authorized by OpenCode or any provider. Full terms are in [License and Disclaimer](#license-and-disclaimer).
+> Independent unofficial community plugin, version **0.7.1**. Package E2E tests exercise the legacy multi-function loader with the OpenCode CLI installed in CI. `@opencode-ai/plugin@1.18.18` is the compile-time plugin API target, not a runtime pin. Source is BSD-3-Clause. This project is not affiliated with, endorsed by, sponsored by, or authorized by OpenCode or any provider. Full terms are in [License and Disclaimer](#license-and-disclaimer).
 
 Reuse the Claude, Cursor, Command Code, and Ollama sessions you already have. One `opencode.json` plugin entry publishes live catalogs into OpenCode. Claude and Cursor stay disconnected until OpenCode has a marker or OAuth record and the vendor session is present. Command Code may use an OpenCode-stored direct API key or an existing CLI session/key. Ollama requires the exact session marker plus a responsive trusted daemon.
 
@@ -55,7 +55,7 @@ OpenCode installs configured npm plugins with Bun at startup and caches them. Fo
 ```jsonc
 {
   "$schema": "https://opencode.ai/config.json",
-  "plugin": ["opencode-ext-connector@0.7.0"]
+  "plugin": ["opencode-ext-connector@0.7.1"]
 }
 ```
 
@@ -109,7 +109,7 @@ Choose `"reader"` on every instance that only consumes synchronized credentials:
 
 `"owner"` internally selects external credential management and enables the Claude CLI authority with its default timing. `"reader"` selects external credential management without starting the CLI authority. The role describes credential ownership, not whether OpenCode runs on a physical host or in a sandbox guest.
 
-Set exactly one owner per shared Claude login. Owner mode requires Linux, util-linux `flock`, Claude Code `2.1.259` or later on `PATH`, and an authenticated Claude Code session. Each authority invocation is a real model request and may consume account usage. A revoked login still requires interactive `/login`.
+Set exactly one owner per shared Claude login. Owner mode requires Linux, util-linux `flock`, Claude Code `2.1.265` or later on `PATH`, and an authenticated Claude Code session. Each authority invocation is a real model request and may consume account usage. A revoked login still requires interactive `/login`.
 
 Do not combine `credentialRole` with `credentialManagement`, `credentialAuthority`, `credentialRefresh`, or `writeBackCredentials`. Existing low-level configurations remain supported for advanced control.
 
@@ -204,7 +204,7 @@ Low-level equivalent:
 }
 ```
 
-After saving the configuration, fully restart OpenCode. The timer requires Linux, util-linux `flock`, Claude Code `2.1.259` or later on `PATH`, an authenticated Claude Code session, and a writable persistent state directory. It is silently disabled on other platforms.
+After saving the configuration, fully restart OpenCode. The timer requires Linux, util-linux `flock`, Claude Code `2.1.265` or later on `PATH`, an authenticated Claude Code session, and a writable persistent state directory. It is silently disabled on other platforms.
 
 `leadMs` and `retryMs` both default to `300000` (5 minutes). The connector schedules one restricted, single-turn Claude request at the lead boundary. A process-shared non-blocking lock prevents concurrent requests from processes using the same state directory; failures retry after `retryMs` without removing the Claude provider.
 

package/dist/core/credential-authority-options.d.ts

@@ -0,0 +1,18 @@
+import { z } from "zod";
+export type ClaudeCliCredentialAuthority = {
+    readonly enabled: boolean;
+    readonly leadMs: number;
+    readonly retryMs: number;
+};
+export type CredentialAuthority = {
+    readonly claudeCli: ClaudeCliCredentialAuthority;
+};
+export type CredentialAuthorityInput = {
+    readonly claudeCli?: {
+        readonly enabled: boolean;
+        readonly leadMs?: number | undefined;
+        readonly retryMs?: number | undefined;
+    } | undefined;
+};
+export declare const CredentialAuthorityInputSchema: z.ZodType<CredentialAuthorityInput, CredentialAuthorityInput>;
+export declare function resolveCredentialAuthority(input: CredentialAuthorityInput | undefined, claudeOwner: boolean): CredentialAuthority;

package/dist/core/credential-authority-options.js

@@ -0,0 +1,25 @@
+import { z } from "zod";
+const SafeIntegerSchema = z.number().int().safe();
+export const CredentialAuthorityInputSchema = z
+    .object({
+    claudeCli: z
+        .object({
+        enabled: z.boolean(),
+        leadMs: SafeIntegerSchema.nonnegative().optional(),
+        retryMs: SafeIntegerSchema.positive().optional(),
+    })
+        .strict()
+        .readonly()
+        .optional(),
+})
+    .strict()
+    .readonly();
+export function resolveCredentialAuthority(input, claudeOwner) {
+    return Object.freeze({
+        claudeCli: Object.freeze({
+            enabled: claudeOwner || (input?.claudeCli?.enabled ?? false),
+            leadMs: input?.claudeCli?.leadMs ?? 300_000,
+            retryMs: input?.claudeCli?.retryMs ?? 300_000,
+        }),
+    });
+}

package/dist/core/options.d.ts

@@ -1,5 +1,7 @@
 import { z } from "zod";
+import { type CredentialAuthority, type CredentialAuthorityInput } from "./credential-authority-options.js";
 import type { HealthPolicy } from "./health.js";
+export type { ClaudeCliCredentialAuthority, CredentialAuthority, } from "./credential-authority-options.js";
 export type CredentialRefreshMode = "auto" | "never";
 export type CredentialManagement = "connector" | "external";
 export type CredentialRole = "owner" | "reader";
@@ -11,27 +13,13 @@ export type CredentialRefreshPolicy = {
     readonly mode: CredentialRefreshMode;
     readonly leadMs: number;
 };
-export type ClaudeCliCredentialAuthority = {
-    readonly enabled: boolean;
-    readonly leadMs: number;
-    readonly retryMs: number;
-};
-export type CredentialAuthority = {
-    readonly claudeCli: ClaudeCliCredentialAuthority;
-};
 export type ConnectorOptionsInput = {
     readonly providers?: readonly ("claude" | "cursor" | "command-code" | "ollama")[] | undefined;
     readonly snapshotTimeoutMs?: number | undefined;
     readonly credentialRole?: CredentialRole | undefined;
     readonly xaiOAuth?: XaiOAuthOptions | undefined;
     readonly credentialManagement?: CredentialManagement | undefined;
-    readonly credentialAuthority?: {
-        readonly claudeCli: {
-            readonly enabled: boolean;
-            readonly leadMs?: number | undefined;
-            readonly retryMs?: number | undefined;
-        };
-    } | undefined;
+    readonly credentialAuthority?: CredentialAuthorityInput | undefined;
     /** @deprecated Use credentialManagement instead. */
     readonly writeBackCredentials?: boolean | undefined;
     /** @deprecated Use credentialManagement instead. */

package/dist/core/options.js

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import { CredentialAuthorityInputSchema, resolveCredentialAuthority, } from "./credential-authority-options.js";
 const MaximumTimerMs = 2_147_483_647;
 const PositiveSafeIntegerSchema = z.number().int().positive().max(MaximumTimerMs);
 const NonNegativeSafeIntegerSchema = z.number().int().nonnegative().max(MaximumTimerMs);
@@ -10,26 +11,12 @@ const XaiOAuthSchema = z
     .object({ mode: z.enum(["authority", "consumer"]) })
     .strict()
     .readonly();
-const SafeIntegerSchema = z.number().int().safe();
 const DefaultProviders = [
     "claude",
     "cursor",
     "command-code",
     "ollama",
 ];
-const CredentialAuthorityInputSchema = z
-    .object({
-    claudeCli: z
-        .object({
-        enabled: z.boolean(),
-        leadMs: SafeIntegerSchema.nonnegative().optional(),
-        retryMs: SafeIntegerSchema.positive().optional(),
-    })
-        .strict()
-        .readonly(),
-})
-    .strict()
-    .readonly();
 function resolveCredentialOptions(input) {
     const credentialManagement = input.credentialRole === undefined ? input.credentialManagement : "external";
     switch (credentialManagement) {
@@ -99,7 +86,7 @@ const ConnectorOptionsInputSchema = z
             message: "`credentialManagement` cannot be combined with deprecated `credentialRefresh` or `writeBackCredentials`",
         });
     }
-    if (input.credentialAuthority?.claudeCli.enabled === true &&
+    if (input.credentialAuthority?.claudeCli?.enabled === true &&
         (input.credentialManagement !== "external" ||
             !(input.providers ?? DefaultProviders).includes("claude"))) {
         context.addIssue({
@@ -128,15 +115,7 @@ export const ConnectorOptionsSchema = ConnectorOptionsInputSchema.transform((inp
         maximumBackoffMs: input.health?.maximumBackoffMs ?? 60_000,
     });
     const credentialOptions = resolveCredentialOptions(input);
-    const credentialAuthority = Object.freeze({
-        claudeCli: Object.freeze({
-            enabled: input.credentialRole === "owner"
-                ? true
-                : (input.credentialAuthority?.claudeCli.enabled ?? false),
-            leadMs: input.credentialAuthority?.claudeCli.leadMs ?? 300_000,
-            retryMs: input.credentialAuthority?.claudeCli.retryMs ?? 300_000,
-        }),
-    });
+    const credentialAuthority = resolveCredentialAuthority(input.credentialAuthority, input.credentialRole === "owner");
     const xaiOAuth = input.xaiOAuth === undefined ? null : Object.freeze(input.xaiOAuth);
     return Object.freeze({
         providers: Object.freeze(input.providers ?? DefaultProviders),

package/dist/providers/claude/credential-authority-scheduler.js

@@ -8,6 +8,7 @@ const LOCK_FILE = "authority.lock";
 const LOCK_CONFLICT_EXIT_CODE = 75;
 const MAXIMUM_DELAY_MS = 2_147_483_647;
 const AUTHORITY_PROMPT = "Reply OK without using tools.";
+const ANTHROPIC_API_KEY = "ANTHROPIC_API_KEY";
 function authorityStateDirectory(env) {
     const configuredState = env.XDG_STATE_HOME;
     if (configuredState !== undefined && configuredState.length > 0 && isAbsolute(configuredState)) {
@@ -24,6 +25,15 @@ async function createStateDirectory(path) {
 function assertNeverProcessExit(exit) {
     throw new InvalidArgumentError("processExit", exit);
 }
+function authorityChildEnvironment(env) {
+    const child = {};
+    for (const [key, value] of Object.entries(env)) {
+        if (key === ANTHROPIC_API_KEY || value === undefined)
+            continue;
+        child[key] = value;
+    }
+    return Object.freeze(child);
+}
 export function createClaudeCredentialAuthorityScheduler(options) {
     if (!Number.isSafeInteger(options.leadMs) || options.leadMs < 0) {
         throw new InvalidArgumentError("leadMs");
@@ -55,6 +65,8 @@ export function createClaudeCredentialAuthorityScheduler(options) {
         if (stateDirectory === null)
             return null;
         await ensureStateDirectory(stateDirectory);
+        // Use the stored OAuth login even when the parent has an API key.
+        const environment = authorityChildEnvironment(options.env);
         const process = await options.processSupervisor.start({
             executable: "flock",
             arguments: [
@@ -77,6 +89,7 @@ export function createClaudeCredentialAuthorityScheduler(options) {
                 "json",
             ],
             cwd: stateDirectory,
+            environment,
         }, controller.signal);
         activeProcess = process;
         try {

package/dist/server.js

@@ -79,7 +79,7 @@ export const connectorServer = async (input, options) => {
     })(input, options);
     const processSupervisor = createProductionProcessSupervisor();
     const claudeCliAuthority = connectorOptions.credentialAuthority.claudeCli;
-    const credentialAuthority = createClaudeCredentialAuthorityScheduler({
+    const claudeCredentialAuthority = createClaudeCredentialAuthorityScheduler({
         enabled: claudeCliAuthority.enabled,
         clock,
         leadMs: claudeCliAuthority.leadMs,
@@ -97,7 +97,7 @@ export const connectorServer = async (input, options) => {
     const dispose = hooks.dispose;
     const disposal = createAsyncDisposable(async () => {
         const results = await Promise.allSettled([
-            Promise.resolve().then(() => credentialAuthority.dispose()),
+            Promise.resolve().then(() => claudeCredentialAuthority.dispose()),
             Promise.resolve().then(() => xaiAuthority.dispose()),
             Promise.resolve().then(() => processSupervisor.dispose()),
             Promise.resolve().then(() => dispose?.()),

package/docs/README.ko.md

@@ -19,7 +19,7 @@
 
 ## 상태
 
-> 독립적인 비공식 커뮤니티 플러그인, 버전 **0.7.0**. CI에 설치된 OpenCode CLI를 대상으로 legacy multi-function 로더를 패키지 E2E 테스트로 검증합니다. `@opencode-ai/plugin@1.18.18`은 컴파일 시 사용하는 플러그인 API 대상이며 OpenCode 런타임 버전 고정이 아닙니다. 소스는 BSD-3-Clause입니다. 이 프로젝트는 OpenCode 또는 어떤 프로바이더와도 제휴, 보증, 후원, 승인 관계가 없습니다. 전체 조건은 [라이선스 및 면책 조항](#라이선스-및-면책-조항)에 있습니다.
+> 독립적인 비공식 커뮤니티 플러그인, 버전 **0.7.1**. CI에 설치된 OpenCode CLI를 대상으로 legacy multi-function 로더를 패키지 E2E 테스트로 검증합니다. `@opencode-ai/plugin@1.18.18`은 컴파일 시 사용하는 플러그인 API 대상이며 OpenCode 런타임 버전 고정이 아닙니다. 소스는 BSD-3-Clause입니다. 이 프로젝트는 OpenCode 또는 어떤 프로바이더와도 제휴, 보증, 후원, 승인 관계가 없습니다. 전체 조건은 [라이선스 및 면책 조항](#라이선스-및-면책-조항)에 있습니다.
 
 이미 가지고 있는 Claude, Cursor, Command Code, Ollama 세션을 재사용합니다. `opencode.json` 플러그인 항목 하나가 라이브 카탈로그를 OpenCode에 공개합니다. Claude와 Cursor는 OpenCode에 마커 또는 OAuth 레코드가 있고 벤더 세션이 있을 때까지 연결되지 않은 상태로 유지됩니다. Command Code는 OpenCode에 저장된 직접 API 키 또는 기존 CLI 세션/키를 사용할 수 있습니다. Ollama는 정확한 세션 마커와 응답하는 신뢰된 데몬이 필요합니다.
 
@@ -55,7 +55,7 @@ OpenCode는 시작 시 Bun으로 설정된 npm 플러그인을 설치하고 캐
 ```jsonc
 {
   "$schema": "https://opencode.ai/config.json",
-  "plugin": ["opencode-ext-connector@0.7.0"]
+  "plugin": ["opencode-ext-connector@0.7.1"]
 }
 ```
 
@@ -109,7 +109,7 @@ OpenCode는 플러그인 옵션을 두 요소 튜플의 두 번째 항목으로
 
 `"owner"`는 내부적으로 external 자격 증명 관리를 선택하고 기본 타이밍으로 Claude CLI 권한을 활성화합니다. `"reader"`는 CLI 권한을 시작하지 않고 external 자격 증명 관리를 선택합니다. 이 역할은 자격 증명 소유권을 뜻하며 OpenCode가 물리 호스트에서 실행되는지, 샌드박스 게스트에서 실행되는지를 뜻하지 않습니다.
 
-공유 Claude 로그인마다 owner를 정확히 하나만 설정하십시오. Owner 모드에는 Linux, util-linux `flock`, `PATH`의 Claude Code `2.1.259` 이상, 인증된 Claude Code 세션이 필요합니다. 각 권한 호출은 실제 모델 요청이며 계정 사용량을 소비할 수 있습니다. 폐기된 로그인은 여전히 대화형 `/login`이 필요합니다.
+공유 Claude 로그인마다 owner를 정확히 하나만 설정하십시오. Owner 모드에는 Linux, util-linux `flock`, `PATH`의 Claude Code `2.1.265` 이상, 인증된 Claude Code 세션이 필요합니다. 각 권한 호출은 실제 모델 요청이며 계정 사용량을 소비할 수 있습니다. 폐기된 로그인은 여전히 대화형 `/login`이 필요합니다.
 
 `credentialRole`을 `credentialManagement`, `credentialAuthority`, `credentialRefresh`, `writeBackCredentials`와 함께 사용하지 마십시오. 기존 저수준 설정은 고급 제어용으로 계속 지원됩니다.
 
@@ -204,7 +204,7 @@ Anthropic은 갱신할 때마다 refresh 토큰을 회전시키고 이전 토큰
 }
 ```
 
-설정을 저장한 뒤 OpenCode를 완전히 재시작하십시오. 타이머는 Linux, `PATH`의 util-linux `flock`, Claude Code `2.1.259` 이상, 인증된 Claude Code 세션, writable persistent 상태 디렉터리가 필요합니다. 다른 플랫폼에서는 조용히 비활성화됩니다.
+설정을 저장한 뒤 OpenCode를 완전히 재시작하십시오. 타이머는 Linux, `PATH`의 util-linux `flock`, Claude Code `2.1.265` 이상, 인증된 Claude Code 세션, writable persistent 상태 디렉터리가 필요합니다. 다른 플랫폼에서는 조용히 비활성화됩니다.
 
 `leadMs`와 `retryMs`의 기본값은 모두 `300000`(5분)입니다. 커넥터는 lead 경계에서 restricted single-turn Claude 요청 하나를 예약합니다. 프로세스 공유 non-blocking lock이 같은 상태 디렉터리를 사용하는 프로세스의 동시 요청을 막고, 실패하면 Claude 프로바이더를 제거하지 않은 채 `retryMs` 후 재시도합니다.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-ext-connector",
-  "version": "0.7.0",
+  "version": "0.7.1",
   "description": "External provider connector for OpenCode",
   "type": "module",
   "license": "BSD-3-Clause",