@cortexkit/opencode-anthropic-auth 1.23.0 → 2.0.0

package/dist/rpc/rpc-client.d.ts

@@ -1,6 +1,8 @@
+import type { CommandApplyRequest, CommandApplyResult } from '@cortexkit/anthropic-auth-core';
 import type { ApplyRequest, ApplyResult, RpcNotification } from './protocol';
 export interface RpcClient {
     pending: (lastReceivedId: number, sessionId: string) => Promise<RpcNotification[]>;
     apply: (request: ApplyRequest) => Promise<ApplyResult>;
+    applyMenu: (request: CommandApplyRequest) => Promise<CommandApplyResult>;
 }
 export declare function createRpcClient(dir: string, expectedPid?: number): RpcClient;

package/dist/rpc/rpc-client.js

@@ -1 +1 @@
-import{ph as l}from"../index-0jfsxyn9.js";import"../index-n96q8pks.js";async function a(n,e,t,o){let r=await l(n,o);if(!r)return null;let i=new AbortController,p=setTimeout(()=>i.abort(),2000);try{let s=await fetch(`http://127.0.0.1:${r.port}/rpc/${e}`,{method:"POST",headers:{"content-type":"application/json",authorization:`Bearer ${r.token}`},body:JSON.stringify(t),signal:i.signal});if(!s.ok)return null;return await s.json()}catch{return null}finally{clearTimeout(p)}}function u(n,e){return{async pending(t,o){return(await a(n,"pending-notifications",{lastReceivedId:t,sessionId:o},e))?.messages??[]},async apply(t){return await a(n,"apply",{...t},e)??{text:"apply failed",knobs:{}}}}}export{u as createRpcClient};
+import{qe as s}from"../index-4ya27n12.js";import"../index-aaajxwzd.js";async function i(e,o,t,n){let r=await s(e,n);if(!r)return null;let a=new AbortController,l=setTimeout(()=>a.abort(),2000);try{let p=await fetch(`http://127.0.0.1:${r.port}/rpc/${o}`,{method:"POST",headers:{"content-type":"application/json",authorization:`Bearer ${r.token}`},body:JSON.stringify(t),signal:a.signal});if(!p.ok)return null;return await p.json()}catch{return null}finally{clearTimeout(l)}}function c(e,o){return{async pending(t,n){return(await i(e,"pending-notifications",{lastReceivedId:t,sessionId:n},o))?.messages??[]},async apply(t){return await i(e,"apply",{...t},o)??{text:"apply failed",knobs:{}}},async applyMenu(t){if(t.command!=="claude"||!t.sessionId?.trim())throw TypeError("A claude menu sessionId is required");let n=await i(e,"apply-menu",{...t},o);if(!n)throw Error("Menu apply unavailable; outcome unknown");return n}}}export{c as createRpcClient};

package/dist/rpc/rpc-dir.js

@@ -1 +1 @@
-import{rh as a,sh as b}from"../index-1gr8v4fn.js";import"../index-n96q8pks.js";export{a as tmpdir,b as getRpcDir};
+import{q as a,r as b}from"../index-rqync0pc.js";import"../index-aaajxwzd.js";export{a as tmpdir,b as getRpcDir};

package/dist/rpc/rpc-server.d.ts

@@ -1,3 +1,4 @@
+import { type CommandApplyRequest, type CommandApplyResult } from '@cortexkit/anthropic-auth-core';
 import type { drainNotifications } from './notifications';
 import type { ApplyRequest, ApplyResult } from './protocol';
 export interface RpcServerHandle {
@@ -8,6 +9,9 @@ export interface RpcServerHandle {
 export interface RpcServerOptions {
     dir: string;
     drain: typeof drainNotifications;
-    apply: (request: ApplyRequest) => Promise<ApplyResult>;
+    /** Structured-menu hosts need no text parser; internal text consumers may still supply one. */
+    apply?: (request: ApplyRequest) => Promise<ApplyResult>;
+    /** Run menu actions through the host's credential service, not legacy account-file writes. */
+    applyMenu?: (request: CommandApplyRequest) => Promise<CommandApplyResult>;
 }
 export declare function startRpcServer(options: RpcServerOptions): Promise<RpcServerHandle>;

package/dist/setup/command.d.ts

@@ -1,8 +1,20 @@
+import type { Writable } from 'node:stream';
+import { detectAll } from './detect.ts';
+import { activateNativeVaultForHost } from './native-activation.ts';
+import { migrateNativeLocalForHost } from './native-local.ts';
+import { loginNativeOffline } from './native-login.ts';
 import type { CommandRunner, ProcessFence } from './types.ts';
 export interface SetupCommandOptions {
     runner?: CommandRunner;
     fence?: ProcessFence;
     env?: NodeJS.ProcessEnv;
     isInteractive?: boolean;
+    /** Let tests substitute host detection and per-host vault activation. */
+    detect?: typeof detectAll;
+    activate?: typeof activateNativeVaultForHost;
+    migrateLocal?: typeof migrateNativeLocalForHost;
+    localLogin?: typeof loginNativeOffline;
+    /** Where setup prints its progress and errors; defaults to stdout. */
+    output?: Writable;
 }
 export declare function runSetupCommand(argv?: string[], options?: SetupCommandOptions): Promise<number>;

package/dist/setup/command.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/setup/native-activation.d.ts

@@ -0,0 +1,29 @@
+import { type NativeCustodyActivationHooks, type NativeCustodyInventory } from '@cortexkit/anthropic-auth-core';
+import { type NativeVaultEnrollmentOptions } from './native-enrollment.ts';
+import { type NativeSetupPaths } from './native-paths.ts';
+import type { CommandRunner, HarnessKind, ProcessFence } from './types.ts';
+export declare class NativeVaultActivationError extends Error {
+    readonly code: 'auth-content-refused' | 'host-auth-invalid' | 'primary-conflict' | 'consent-required' | 'primary-unverified';
+    constructor(code: 'auth-content-refused' | 'host-auth-invalid' | 'primary-conflict' | 'consent-required' | 'primary-unverified');
+}
+export interface NativeVaultActivationOptions {
+    env: NodeJS.ProcessEnv;
+    runner: CommandRunner;
+    fence: ProcessFence;
+    /** Consent to move Pi's stored authentication aside; never consent to delete it. */
+    removePiAnthropicAuth: boolean;
+    /**
+     * Tests override the host paths, enrollment client and vault listing;
+     * production resolves them from the host's environment.
+     */
+    paths?: NativeSetupPaths;
+    enrollment?: Pick<NativeVaultEnrollmentOptions, 'paths' | 'client' | 'ckBinary' | 'connectionFile'>;
+    discover?: () => Promise<NativeCustodyInventory>;
+    hooks?: NativeCustodyActivationHooks;
+}
+/**
+ * Enroll this stopped host, discover its verified default vault account and
+ * leave the host auth slot untouched. Local credentials, migration journal,
+ * account metadata and routing assignments are not inputs to this operation.
+ */
+export declare function activateNativeVaultForHost(host: HarnessKind, options: NativeVaultActivationOptions): Promise<'committed' | 'already-vault'>;

package/dist/setup/native-enrollment.d.ts

@@ -0,0 +1,26 @@
+import { type ClaustrumEnrollmentClient, type ClaustrumEnrollmentPaths } from '@cortexkit/common-auth/claustrum';
+import type { CommandRunner, HarnessKind } from './types.ts';
+export interface NativeVaultEnrollmentOptions {
+    env: NodeJS.ProcessEnv;
+    runner: CommandRunner;
+    /**
+     * Check that selected host processes are stopped and their inspection succeeded,
+     * and reject an inherited OPENCODE_AUTH_CONTENT snapshot. These checks run
+     * before each enrollment request, token write and permission change.
+     */
+    processFence: () => Promise<void>;
+    paths?: ClaustrumEnrollmentPaths;
+    client?: ClaustrumEnrollmentClient;
+    ckBinary?: string;
+    connectionFile?: string;
+}
+export declare class NativeVaultEnrollmentError extends Error {
+    readonly code: 'enrollment-refused' | 'enrollment-reset' | 'approval-refused' | 'permission-refused';
+    constructor(code: 'enrollment-refused' | 'enrollment-reset' | 'approval-refused' | 'permission-refused');
+}
+/**
+ * Enroll this stopped host and grant permission to list native Claude accounts.
+ * This function does not fetch OAuth tokens or change which store serves requests;
+ * account discovery and the credential-store switch are separate setup steps.
+ */
+export declare function enrollNativeVaultForHost(host: HarnessKind, options: NativeVaultEnrollmentOptions): Promise<void>;

package/dist/setup/native-enrollment.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/setup/native-local.d.ts

@@ -0,0 +1,20 @@
+import { type NativeSetupPaths } from './native-paths';
+import type { HarnessKind, ProcessFence } from './types';
+export interface NativeOfflineLogin {
+    credential: {
+        type: 'oauth';
+        access: string;
+        refresh: string;
+        expires: number;
+    };
+    accountIdentity: string;
+}
+export interface NativeLocalSetupOptions {
+    env: NodeJS.ProcessEnv;
+    fence: ProcessFence;
+    paths?: NativeSetupPaths;
+    removePiAnthropicAuth: boolean;
+    login?: (host: HarnessKind) => Promise<NativeOfflineLogin>;
+}
+/** Transfer local credentials while hosts are stopped, before telling the user to restart. */
+export declare function migrateNativeLocalForHost(host: HarnessKind, options: NativeLocalSetupOptions): Promise<void>;

package/dist/setup/native-login.d.ts

@@ -0,0 +1,3 @@
+import type { NativeOfflineLogin } from './native-local';
+import type { HarnessKind } from './types';
+export declare function loginNativeOffline(host: HarnessKind): Promise<NativeOfflineLogin>;

package/dist/setup/native-paths.d.ts

@@ -0,0 +1,15 @@
+import { type NativePoolPaths } from '@cortexkit/anthropic-auth-core';
+import type { HarnessKind } from './types.ts';
+export interface NativeSetupPaths {
+    host: HarnessKind;
+    paths: NativePoolPaths;
+    legacyConfigPath: string;
+    legacyStatePath: string;
+    hostAuthPath: string;
+    routingSourcePath: string;
+    routingDestinationPath: string;
+}
+/** Resolve actor-supplied environment without changing ambient process variables. */
+export declare function resolveNativeSetupPaths(host: HarnessKind, env: NodeJS.ProcessEnv): Promise<NativeSetupPaths>;
+/** Reject plans where OpenCode and Pi share credential, journal or routing files. */
+export declare function requireDisjointNativeSetupPaths(plans: readonly NativeSetupPaths[]): Promise<void>;

package/dist/setup/native-paths.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/setup/pi.d.ts

@@ -2,7 +2,17 @@ import type { CommandRunner } from './types.ts';
 export declare function isPiPackageInstalled(env?: NodeJS.ProcessEnv): boolean;
 export declare function hasPiLocalAnthropicAuth(env?: NodeJS.ProcessEnv): Promise<boolean>;
 export declare function cleanPiLocalAnthropicAuth(env?: NodeJS.ProcessEnv): Promise<boolean>;
-export declare function installPiExtension(version: string, runner?: CommandRunner, env?: NodeJS.ProcessEnv): Promise<{
-    ok: boolean;
+/**
+ * A failed install carries the child's raw exit code and stderr for the
+ * diagnostic log only; stderr can echo credentials from the environment, so it
+ * is never meant for the screen.
+ */
+export type PiInstallResult = {
+    ok: true;
     message: string;
-}>;
+} | {
+    ok: false;
+    exitCode: number;
+    stderr: string;
+};
+export declare function installPiExtension(version: string, runner?: CommandRunner, env?: NodeJS.ProcessEnv): Promise<PiInstallResult>;

package/dist/setup/process-fence.d.ts

@@ -1,4 +1,8 @@
 import type { CommandRunner, ProcessFence } from './types.ts';
+export declare class ProcessInspectionError extends Error {
+    readonly code = "process-inspection-failed";
+    constructor();
+}
 export declare class ProcessFenceViolationError extends Error {
     readonly activeHosts: Array<{
         pid: number;
@@ -9,6 +13,8 @@ export declare class ProcessFenceViolationError extends Error {
         command: string;
     }>);
 }
-export declare function createProcessFence(runner?: CommandRunner): ProcessFence;
+export declare function createProcessFence(runner?: CommandRunner, options?: {
+    platform?: NodeJS.Platform;
+}): ProcessFence;
 export declare const defaultProcessFence: ProcessFence;
 export declare function assertHostsStopped(fence?: ProcessFence): Promise<void>;

package/dist/setup/process-fence.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/sidebar-state.js

@@ -1 +1 @@
-import{A as t,B as u,h as a,i as b,j as c,k as d,l as e,m as f,n as g,o as h,p as i,q as j,r as k,s as l,t as m,u as n,v as o,w as p,x as q,y as r,z as s}from"./index-xzbhzz0a.js";import"./index-1fq7h6yd.js";import"./index-a5d6v3ba.js";import"./index-n96q8pks.js";export{i as setSidebarState,k as resolveActiveAccount,c as normalizeSidebarState,a as getSidebarStateFile,h as getSidebarState,f as getInitialSidebarRoutingTestHooks,q as getFableRecoverySummary,r as getCollapsedQuotaSummary,l as formatScopedQuotaLabel,n as formatPrimeTime,o as formatPrimeCost,p as formatPrimeAccountValue,m as formatFallbackModelLabel,j as drainSidebarWrites,u as computeQuotaPacing,d as __setSidebarStateWriteTestHooks,e as __setInitialSidebarRoutingTestHooks,g as __acquireSidebarStateLockForTest,t as SEVEN_DAY_MS,s as FIVE_HOUR_MS,b as DEFAULT_SIDEBAR_STATE};
+import{E as a,F as b,G as c,H as d,I as e,J as f,K as g,L as h,M as i,N as j,O as k,P as l,Q as m,R as n,S as o,T as p,U as q,V as r,W as s,X as t,Y as u}from"./index-fds0s2j4.js";import"./index-nngmvczq.js";import"./index-aaajxwzd.js";export{i as setSidebarState,k as resolveActiveAccount,c as normalizeSidebarState,a as getSidebarStateFile,h as getSidebarState,f as getInitialSidebarRoutingTestHooks,q as getFableRecoverySummary,r as getCollapsedQuotaSummary,l as formatScopedQuotaLabel,n as formatPrimeTime,o as formatPrimeCost,p as formatPrimeAccountValue,m as formatFallbackModelLabel,j as drainSidebarWrites,u as computeQuotaPacing,d as __setSidebarStateWriteTestHooks,e as __setInitialSidebarRoutingTestHooks,g as __acquireSidebarStateLockForTest,t as SEVEN_DAY_MS,s as FIVE_HOUR_MS,b as DEFAULT_SIDEBAR_STATE};

package/dist/tui/command-dialogs.d.ts

@@ -1,8 +1,13 @@
 /** @jsxImportSource @opentui/solid */
+import type { CommandApplyRequest, CommandApplyResult, CommandDialogPayload } from '@cortexkit/anthropic-auth-core';
 import { type PrimeAccountStatus } from '@cortexkit/anthropic-auth-core';
 import type { TuiPluginApi } from '@opencode-ai/plugin/tui';
 import type { AccountDialogAccount } from '../rpc/protocol';
 import type { OpenDialogPayload } from '../rpc/protocol.js';
+/** Render menu sections, accounts and action inputs; send changes to the host instead of writing credentials here. */
+export declare function openNativeMenuDialog(api: {
+    readonly ui: Pick<TuiPluginApi['ui'], 'dialog' | 'DialogSelect' | 'DialogPrompt' | 'DialogConfirm' | 'toast'>;
+}, payload: CommandDialogPayload, apply: (request: CommandApplyRequest) => Promise<CommandApplyResult>, isCurrentSession: () => boolean): void;
 type ApplyFn = (command: OpenDialogPayload['command'], args: string) => Promise<{
     text: string;
     knobs: Record<string, unknown>;

package/dist/tui-preferences.js

@@ -1,6 +1,6 @@
-import{nh as _}from"./index-xxhyhp98.js";import{th as C}from"./index-n96q8pks.js";var W=C(_(),1);import{readFileSync as E,watch as b}from"node:fs";import{mkdir as g,readFile as A,rename as F,writeFile as T}from"node:fs/promises";import{homedir as y}from"node:os";import{basename as f,dirname as x,join as D}from"node:path";import{clearTimeout as U,setTimeout as R}from"node:timers";var v="OPENCODE_TUI_PREFERENCES_FILE",h="tui-preferences.jsonc";function K(){let J=process.env[v];if(J)return J;let z=process.env.OPENCODE_CONFIG_DIR||D(process.env.XDG_CONFIG_HOME||D(y(),".config"),"opencode");return D(z,h)}function H(J){return typeof J==="object"&&J!==null&&!Array.isArray(J)}async function e(){try{let J=await A(K(),"utf8"),z=[],q=W.parse(J,z,{allowTrailingComma:!0});if(z.length>0)return{};return H(q)?q:{}}catch{return{}}}var m="anthropic-auth",p=160,w={forceToTop:!1,order:p,startCollapsed:!1,rememberCollapsed:!0,collapsed:null,pollMs:1500,refreshDebounceMs:200,header:{label:"CLAUDE",showVersion:!0},sections:{quota:!0,fallbackAccounts:!0,routing:!0,cache:!0,health:!0,pacing:!0},appearance:{barWidth:10,barFilledChar:"█",barEmptyChar:"░",warnThreshold:50,errorThreshold:80}};function $(J,z){return typeof J==="boolean"?J:z}function Y(J,z,q,X){if(typeof J!=="number"||!Number.isFinite(J))return z;return Math.min(Math.max(Math.round(J),q),X)}function c(J,z,q){if(typeof J!=="string"||J.length===0)return z;return J.slice(0,q)}function P(J,z){if(typeof J!=="string")return z;return[...J][0]??z}function qq(J){let z=J[m];if(!H(z))return structuredClone(w);let q=w,X=H(z.header)?z.header:{},Q=H(z.sections)?z.sections:{},Z=H(z.appearance)?z.appearance:{},G=Y(Z.warnThreshold,q.appearance.warnThreshold,0,99),V=Math.max(Y(Z.errorThreshold,q.appearance.errorThreshold,0,100),Math.min(G+1,100));return{forceToTop:$(z.forceToTop,q.forceToTop),order:Y(z.order,q.order,-1e4,1e4),startCollapsed:$(z.startCollapsed,q.startCollapsed),rememberCollapsed:$(z.rememberCollapsed,q.rememberCollapsed),collapsed:typeof z.collapsed==="boolean"?z.collapsed:null,pollMs:Y(z.pollMs,q.pollMs,500,30000),refreshDebounceMs:Y(z.refreshDebounceMs,q.refreshDebounceMs,50,5000),header:{label:c(X.label,q.header.label,20),showVersion:$(X.showVersion,q.header.showVersion)},sections:{quota:$(Q.quota,q.sections.quota),fallbackAccounts:$(Q.fallbackAccounts,q.sections.fallbackAccounts),routing:$(Q.routing,q.sections.routing),cache:$(Q.cache,q.sections.cache),health:$(Q.health,q.sections.health),pacing:$(Q.pacing,q.sections.pacing)},appearance:{barWidth:Y(Z.barWidth,q.appearance.barWidth,4,40),barFilledChar:P(Z.barFilledChar,q.appearance.barFilledChar),barEmptyChar:P(Z.barEmptyChar,q.appearance.barEmptyChar),warnThreshold:G,errorThreshold:V}}}var u=-1e5;function zq(J,z,q){let X=J[z];if(!H(X))return q;if(X.forceToTop===!0)return u+Object.keys(J).indexOf(z);return Y(X.order,q,-1e4,1e4)}var s=`// Shared preferences for opencode TUI plugins.
+import"./index-aaajxwzd.js";import{readFileSync as k,watch as C}from"node:fs";import{mkdir as _,readFile as I,rename as E,writeFile as b}from"node:fs/promises";import{homedir as g}from"node:os";import{basename as F,dirname as P,join as N}from"node:path";import{clearTimeout as D,setTimeout as L}from"node:timers";import{applyEdits as T,modify as y,parse as f}from"jsonc-parser";var v="OPENCODE_TUI_PREFERENCES_FILE",h="tui-preferences.jsonc";function A(){let J=process.env[v];if(J)return J;let z=process.env.OPENCODE_CONFIG_DIR||N(process.env.XDG_CONFIG_HOME||N(g(),".config"),"opencode");return N(z,h)}function H(J){return typeof J==="object"&&J!==null&&!Array.isArray(J)}async function qq(){try{let J=await I(A(),"utf8"),z=[],q=f(J,z,{allowTrailingComma:!0});if(z.length>0)return{};return H(q)?q:{}}catch{return{}}}var m="anthropic-auth",p=160,R={forceToTop:!1,order:p,startCollapsed:!1,rememberCollapsed:!0,collapsed:null,pollMs:1500,refreshDebounceMs:200,header:{label:"CLAUDE",showVersion:!0},sections:{quota:!0,fallbackAccounts:!0,routing:!0,cache:!0,health:!0,pacing:!0},appearance:{barWidth:10,barFilledChar:"█",barEmptyChar:"░",warnThreshold:50,errorThreshold:80}};function $(J,z){return typeof J==="boolean"?J:z}function Y(J,z,q,X){if(typeof J!=="number"||!Number.isFinite(J))return z;return Math.min(Math.max(Math.round(J),q),X)}function c(J,z,q){if(typeof J!=="string"||J.length===0)return z;return J.slice(0,q)}function w(J,z){if(typeof J!=="string")return z;return[...J][0]??z}function zq(J){let z=J[m];if(!H(z))return structuredClone(R);let q=R,X=H(z.header)?z.header:{},Q=H(z.sections)?z.sections:{},Z=H(z.appearance)?z.appearance:{},G=Y(Z.warnThreshold,q.appearance.warnThreshold,0,99),V=Math.max(Y(Z.errorThreshold,q.appearance.errorThreshold,0,100),Math.min(G+1,100));return{forceToTop:$(z.forceToTop,q.forceToTop),order:Y(z.order,q.order,-1e4,1e4),startCollapsed:$(z.startCollapsed,q.startCollapsed),rememberCollapsed:$(z.rememberCollapsed,q.rememberCollapsed),collapsed:typeof z.collapsed==="boolean"?z.collapsed:null,pollMs:Y(z.pollMs,q.pollMs,500,30000),refreshDebounceMs:Y(z.refreshDebounceMs,q.refreshDebounceMs,50,5000),header:{label:c(X.label,q.header.label,20),showVersion:$(X.showVersion,q.header.showVersion)},sections:{quota:$(Q.quota,q.sections.quota),fallbackAccounts:$(Q.fallbackAccounts,q.sections.fallbackAccounts),routing:$(Q.routing,q.sections.routing),cache:$(Q.cache,q.sections.cache),health:$(Q.health,q.sections.health),pacing:$(Q.pacing,q.sections.pacing)},appearance:{barWidth:Y(Z.barWidth,q.appearance.barWidth,4,40),barFilledChar:w(Z.barFilledChar,q.appearance.barFilledChar),barEmptyChar:w(Z.barEmptyChar,q.appearance.barEmptyChar),warnThreshold:G,errorThreshold:V}}}var u=-1e5;function Jq(J,z,q){let X=J[z];if(!H(X))return q;if(X.forceToTop===!0)return u+Object.keys(J).indexOf(z);return Y(X.order,q,-1e4,1e4)}var s=`// Shared preferences for opencode TUI plugins.
 // One top-level key per plugin (short name). See each plugin's README for
 // its supported settings. This file is safe to hand-edit; plugins update
 // individual keys in place and preserve comments.
 {}
-`;async function d(J,z,q){let X=K();await g(x(X),{recursive:!0});let Q;try{Q=await A(X,"utf8")}catch{Q=""}if(Q.trim()==="")Q=s;let Z=W.modify(Q,[J,...z],q,{formattingOptions:{insertSpaces:!0,tabSize:2}}),G=W.applyEdits(Q,Z),V=`${X}.${process.pid}.tmp`;await T(V,G,"utf8"),await F(V,X)}var I=Promise.resolve();function Jq(J,z,q){return I=I.then(()=>d(J,z,q)).catch(()=>{}),I}var o=150,n=100;function Qq(J,z={}){let q=K(),X=f(q),Q=null,Z=null;try{Z=E(q,"utf8")}catch{}let G=!1,V=async()=>{let j=await A(q,"utf8").catch(()=>null);if(G||j===null)return;if(j===Z)return;Z=j,J()},S=()=>{if(Q)U(Q);Q=R(()=>{Q=null,V()},o)},O=null;try{O=(z.watchDirectory??b)(x(q),(j,M)=>{let k=M===X||M?.startsWith(`${X}.`)&&M.endsWith(".tmp");if(M!=null&&!k)return;S()})}catch{if(Z===null)return()=>{}}let B=null,N=!1,L=()=>{if(G||B)return;B=R(()=>{if(B=null,G||N)return;N=!0,V().finally(()=>{N=!1,L()})},n),B.unref?.()};return L(),()=>{if(G=!0,Q)U(Q);if(B)U(B);O?.close()}}export{Qq as watchTuiPreferences,qq as resolveAnthropicAuthPrefs,e as readTuiPreferencesFile,Jq as queueTuiPreferenceUpdate,K as getTuiPreferencesFile,zq as computeEffectiveOrder,v as TUI_PREFS_FILE_ENV,m as PLUGIN_KEY,p as DEFAULT_SLOT_ORDER,w as DEFAULT_PREFS};
+`;async function d(J,z,q){let X=A();await _(P(X),{recursive:!0});let Q;try{Q=await I(X,"utf8")}catch{Q=""}if(Q.trim()==="")Q=s;let Z=y(Q,[J,...z],q,{formattingOptions:{insertSpaces:!0,tabSize:2}}),G=T(Q,Z),V=`${X}.${process.pid}.tmp`;await b(V,G,"utf8"),await E(V,X)}var U=Promise.resolve();function Qq(J,z,q){return U=U.then(()=>d(J,z,q)).catch(()=>{}),U}var o=150,n=100;function Xq(J,z={}){let q=A(),X=F(q),Q=null,Z=null;try{Z=k(q,"utf8")}catch{}let G=!1,V=async()=>{let W=await I(q,"utf8").catch(()=>null);if(G||W===null)return;if(W===Z)return;Z=W,J()},x=()=>{if(Q)D(Q);Q=L(()=>{Q=null,V()},o)},K=null;try{K=(z.watchDirectory??C)(P(q),(W,j)=>{let S=j===X||j?.startsWith(`${X}.`)&&j.endsWith(".tmp");if(j!=null&&!S)return;x()})}catch{if(Z===null)return()=>{}}let B=null,M=!1,O=()=>{if(G||B)return;B=L(()=>{if(B=null,G||M)return;M=!0,V().finally(()=>{M=!1,O()})},n),B.unref?.()};return O(),()=>{if(G=!0,Q)D(Q);if(B)D(B);K?.close()}}export{Xq as watchTuiPreferences,zq as resolveAnthropicAuthPrefs,qq as readTuiPreferencesFile,Qq as queueTuiPreferenceUpdate,A as getTuiPreferencesFile,Jq as computeEffectiveOrder,v as TUI_PREFS_FILE_ENV,m as PLUGIN_KEY,p as DEFAULT_SLOT_ORDER,R as DEFAULT_PREFS};

package/dist/v2/activation.d.ts

@@ -0,0 +1,7 @@
+/** Explicit sign-in to the native Claude account pool creates this OAuth connection. Startup leaves existing OpenCode connections unchanged. */
+export declare const CLAUDE_POOL_LOGIN_METHOD_ID = "native-claude-oauth";
+/**
+ * Connects OpenCode to the Claude accounts held in the vault. It signs in to
+ * nothing and stores no local account; only the host's placeholder is written.
+ */
+export declare const CLAUDE_VAULT_ACTIVATION_METHOD_ID = "native-claude-vault";

package/dist/v2/adapter.d.ts

@@ -0,0 +1,276 @@
+import { type ClaudeCodeIdentity, TrailingAssistantHistoryError } from '@cortexkit/anthropic-auth-core';
+import type { AccountRequest, AttemptOutcome, ChooseAccountInput, HeaderEdits, HostError, LimitSignal, OpenCode2AuthAdapter, RequestScope, Transport } from '@cortexkit/common-auth/opencode2';
+import { EffortMarkerCorrelationError } from '../effort-history';
+import { createStrippedStream, rewriteRequestBody } from '../transform';
+/** The provider OpenCode 2 serves Claude under. */
+export declare const ANTHROPIC_PROVIDER_ID = "anthropic";
+/**
+ * Plugin-internal request headers that correlate a request with this
+ * plugin's own state. They are meaningful only inside the plugin and are
+ * removed before the request goes upstream, on both routes.
+ */
+export declare const INTERNAL_REQUEST_HEADERS: readonly string[];
+/**
+ * Fixed text of the refusal raised when the source has no credential for a
+ * send. It names no account, route or vault, because the host shows and logs
+ * it.
+ */
+export declare const NO_ACCOUNT_REFUSAL = "Claude pool login is selected but no native account is usable. Complete offline migration or repair the pool and its quota policy before retrying.";
+/**
+ * Most sends whose credential may wait between `accountHeaders` and
+ * `rewriteRequest` at once. Matches the installer's own default record bound;
+ * the oldest is dropped first, and a send whose entry was dropped is refused
+ * rather than sent without it.
+ */
+export declare const DEFAULT_MAX_PENDING_SENDS = 512;
+/**
+ * How long `onAttemptEnd` waits for the source to finish recording how a send
+ * ended. After that the adapter returns and logs a warning; the source's own
+ * work is not cancelled.
+ */
+export declare const DEFAULT_ATTEMPT_END_TIMEOUT_MS = 5000;
+/** Which kind of credential one send goes out with. */
+export type NativeAnthropicRoute = 'oauth' | 'api';
+/**
+ * Where one send goes: directly to Anthropic, or through the selected HTTP
+ * relay. A selected WebSocket relay appears here only so the adapter can
+ * refuse it before anything is sent. No local proxy transport is used.
+ */
+export type NativeAnthropicDispatch = {
+    readonly kind: 'direct';
+} | {
+    readonly kind: 'http-relay';
+    readonly url: string;
+    readonly token: string;
+} | {
+    readonly kind: 'websocket-relay';
+};
+/**
+ * What the source authorizes for one send. `provenance` is the source's own
+ * record of the account and credential version that serve it (a local slot,
+ * a vault receipt with its version, an API key row). The adapter hands it back
+ * unchanged with every response, error and end of that send, so the source
+ * can tie a 401 or a quota reading to the exact account and version served.
+ */
+export type NativeAnthropicAuthorization<P> = {
+    readonly route: 'oauth';
+    readonly accessToken: string;
+    /** The Claude Code identity of the account, when the source knows it. */
+    readonly identity?: ClaudeCodeIdentity;
+    /** Additional OAuth request headers; authorization and x-api-key edits are ignored so they cannot replace the authorized bearer. */
+    readonly headers?: HeaderEdits;
+    readonly provenance: P;
+    readonly dispatch?: NativeAnthropicDispatch;
+} | {
+    readonly route: 'api';
+    /**
+     * API-route authentication headers must set authorization or x-api-key.
+     */
+    readonly headers: HeaderEdits;
+    /** The URL the send goes to instead of the host's, for this account. */
+    readonly baseURL?: string;
+    readonly provenance: P;
+    readonly dispatch?: NativeAnthropicDispatch;
+};
+/**
+ * Correlation metadata carried by common-auth's request hooks for one send.
+ * It contains neither credentials nor request body content.
+ */
+export interface NativeAnthropicAttemptData<P> {
+    readonly route: NativeAnthropicRoute;
+    readonly provenance: P;
+    readonly dispatch: 'direct' | 'http-relay';
+}
+/**
+ * One send, as the source's response, error and end callbacks receive it:
+ * the host's request scope, the attempt, and what the source authorized.
+ */
+export interface NativeAnthropicAttemptContext<P> extends AccountRequest {
+    readonly attemptId: string;
+    readonly transport: Transport | undefined;
+    readonly route: NativeAnthropicRoute;
+    readonly provenance: P;
+    readonly dispatch: 'direct' | 'http-relay';
+}
+/** Non-nullable options accepted by rewriteRequestBody. */
+type RewriteBodyOptions = NonNullable<Parameters<typeof rewriteRequestBody>[1]>;
+/**
+ * The body rewrite options a source supplies for an OAuth send: billing
+ * lineage, effort plan, cache, fast mode, safety and diagnostics inputs. Two
+ * options are left out because the adapter sets them: the Claude Code
+ * identity, which the source returns with the credential, and the session id,
+ * which is the host's own session id for the request.
+ */
+export type NativeAnthropicBodyOptions = Omit<RewriteBodyOptions, 'identity' | 'sessionId'>;
+type StrippedStreamOptions = NonNullable<Parameters<typeof createStrippedStream>[1]>;
+/**
+ * The response observers a source may attach to an OAuth response. Content
+ * filter recovery and relay error hooks are left out on purpose: they exist
+ * to send the request again, and this adapter never sends.
+ */
+export type NativeAnthropicResponseOptions = Pick<StrippedStreamOptions, 'perf' | 'onComplete' | 'serverSideFallbackModel' | 'onServerSideFallbackOutcome' | 'onMessageStart' | 'onMessageDelta' | 'onMessageResponse' | 'onStreamEnd' | 'laneStart'>;
+/** What `requestOptions` receives for an OAuth send, before its body is rewritten. */
+export interface NativeAnthropicRequestContext<P> extends NativeAnthropicAttemptContext<P> {
+    readonly route: 'oauth';
+    /**
+     * This plugin's own correlation headers found on the request (lower-case
+     * names, such as the effort plan or billing lineage id), already removed
+     * from it. The adapter does not interpret them; the source looks them up
+     * in its own trackers.
+     */
+    readonly correlation: Readonly<Record<string, string>>;
+}
+/**
+ * What the source's response callbacks receive: the send, plus the HTTP
+ * status of its response, before the body is read.
+ */
+export interface NativeAnthropicResponseContext<P> extends NativeAnthropicAttemptContext<P> {
+    readonly status: number;
+}
+/** An `error` event inside a streamed response. */
+export interface NativeAnthropicStreamErrorContext<P> extends NativeAnthropicAttemptContext<P> {
+    /** The provider's `error.type`, such as `overloaded_error`. */
+    readonly errorType: string | undefined;
+    readonly message: string | undefined;
+}
+/**
+ * How a send ended. `localRefusal` is set when the adapter refused the
+ * request itself before anything was sent (a malformed history, say); a
+ * provider 400 never carries it.
+ */
+export interface NativeAnthropicAttemptOutcome extends AttemptOutcome {
+    readonly localRefusal?: {
+        readonly check: string;
+    };
+}
+/**
+ * The Core-owned source of accounts and policy. Every member is a function
+ * property, so under `strictFunctionTypes` a callback that accepts less than
+ * the adapter passes it is rejected at compile time.
+ */
+export interface NativeAnthropicSource<Q, P> {
+    /** Picks the account for one request; `undefined` refuses it. */
+    readonly chooseAccount: (input: ChooseAccountInput) => Promise<string | undefined> | string | undefined;
+    /**
+     * The credential for one send with the chosen account; `undefined` refuses
+     * the request before anything is sent.
+     */
+    readonly authorizeAccount: (scope: RequestScope, accountId: string) => Promise<NativeAnthropicAuthorization<P> | undefined> | NativeAnthropicAuthorization<P> | undefined;
+    /** Body rewrite options for an OAuth send. */
+    readonly requestOptions?: (input: NativeAnthropicRequestContext<P>) => Promise<NativeAnthropicBodyOptions> | NativeAnthropicBodyOptions;
+    /** Rechecks policy after asynchronous rewriting, immediately before dispatch. */
+    readonly admitRequest?: (input: NativeAnthropicAttemptContext<P>) => Promise<void> | void;
+    /** Response observers for an OAuth response. */
+    readonly responseOptions?: (input: NativeAnthropicResponseContext<P>) => NativeAnthropicResponseOptions | undefined;
+    /** Quota carried by the upstream response headers, read once per response. */
+    readonly quotaFromHeaders?: (headers: Headers, input: NativeAnthropicResponseContext<P>) => Q | undefined;
+    /**
+     * Classifies an error response before its body streams. `body()` reads a
+     * copy, so the host still receives the body.
+     */
+    readonly limitFromResponse?: (input: NativeAnthropicResponseContext<P> & {
+        readonly headers: Headers;
+        readonly body: () => Promise<string>;
+    }) => Promise<LimitSignal | undefined> | LimitSignal | undefined;
+    /** Classifies a relay-local failure, never an Anthropic credential failure. */
+    readonly limitFromRelayFailure?: (input: NativeAnthropicResponseContext<P>) => Promise<LimitSignal | undefined> | LimitSignal | undefined;
+    /** Classifies an `error` event inside a streamed response. */
+    readonly limitFromStreamError?: (input: NativeAnthropicStreamErrorContext<P>) => LimitSignal | undefined;
+    /**
+     * Classifies the error the host hands the retry hook. Never asked about a
+     * send the adapter refused locally.
+     */
+    readonly limitFromHostError?: (error: HostError, input: NativeAnthropicAttemptContext<P>) => LimitSignal | undefined;
+    /**
+     * How a send ended, with the provenance of the credential it used, so a
+     * 401 can be reported against the exact vault receipt version served.
+     */
+    readonly onAttemptEnd?: (input: NativeAnthropicAttemptContext<P>, outcome: NativeAnthropicAttemptOutcome) => Promise<void> | void;
+    /**
+     * Called by the adapter's `forgetSession`; drops whatever the source keeps
+     * for the session.
+     */
+    readonly forgetSession?: (sessionID: string) => void;
+}
+export interface NativeAnthropicAdapterLogger {
+    warn(message: string, data?: Record<string, unknown>): void;
+}
+export interface NativeAnthropicAdapterDeps<Q, P> {
+    readonly source: NativeAnthropicSource<Q, P>;
+    readonly log?: NativeAnthropicAdapterLogger;
+    /** Maximum number of authorized sends waiting for their request rewrite. */
+    readonly maxPendingSends?: number;
+    /**
+     * How long `onAttemptEnd` waits for the source to record how a send
+     * ended; the source's work is not cancelled.
+     */
+    readonly attemptEndTimeoutMs?: number;
+}
+export interface NativeAnthropicAdapter<Q, P> {
+    readonly adapter: OpenCode2AuthAdapter<Q, NativeAnthropicAttemptData<P>>;
+    /**
+     * Drops the session's authorized sends that have not been rewritten yet,
+     * revokes its choices, authorizations and rewrites still in progress so
+     * none of them can return, and calls the source's `forgetSession`.
+     */
+    forgetSession(sessionID: string): void;
+    /** Revokes all pending work. Later calls refuse without invoking the source. */
+    dispose(): void;
+    /** Number of sends authorized and not yet rewritten or ended. */
+    readonly pendingSendCount: number;
+    /** Number of OAuth access tokens held for sends not yet rewritten. */
+    readonly heldCredentialCount: number;
+    /**
+     * Number of sends whose credentials are still held to scrub their errors:
+     * kept until the send ends cleanly, the retry hook has classified its
+     * failure, its session is forgotten, or maxPendingSends evicts the oldest.
+     */
+    readonly heldRedactorCount: number;
+    /** Number of choices, authorizations and rewrites still in progress. */
+    readonly operationsInProgress: number;
+}
+/**
+ * The request was refused before anything was sent because the source had
+ * no credential for it. Never retried on the host's own credential.
+ */
+export declare class NativeAnthropicNoAccountError extends Error {
+    readonly sessionID: string;
+    readonly requestKind: string;
+    readonly kind = "no-account";
+    readonly providerID = "anthropic";
+    constructor(sessionID: string, requestKind: string);
+}
+/**
+ * The request was refused because its session was forgotten while the
+ * account choice, authorization or request rewrite for it was still in
+ * progress. Nothing from that work is returned or kept, and nothing is sent.
+ */
+export declare class NativeAnthropicRevokedError extends Error {
+    readonly sessionID: string;
+    readonly requestKind: string;
+    readonly kind = "session-forgotten";
+    readonly providerID = "anthropic";
+    constructor(sessionID: string, requestKind: string);
+}
+/** OpenCode 2's HTTP model driver cannot speak the relay's binary WebSocket protocol. */
+export declare class NativeAnthropicTransportRefusal extends Error {
+    readonly kind = "unsupported-transport";
+    readonly providerID = "anthropic";
+    constructor();
+}
+/**
+ * The request was refused with a local 400 because it can never succeed as
+ * written: its history ends on a meaningful assistant turn, or an effort
+ * marker in it cannot be matched to the session's effort plan. Nothing was
+ * sent, and another account cannot help, so the adapter never reports it as
+ * an account limit. The message and `check` describe only the shape of the
+ * problem, never conversation content.
+ */
+export declare class NativeAnthropicLocalRefusal extends Error {
+    readonly kind = "local-invalid-request";
+    readonly status = 400;
+    readonly check: string;
+    constructor(cause: TrailingAssistantHistoryError | EffortMarkerCorrelationError);
+}
+export declare function createNativeAnthropicAdapter<Q, P>(deps: NativeAnthropicAdapterDeps<Q, P>): NativeAnthropicAdapter<Q, P>;
+export {};

package/dist/v2/install.d.ts

@@ -0,0 +1,13 @@
+import { type InstallOpenCode2AuthOptions, type OpenCode2AuthInstallation, type OpenCode2HookContext } from '@cortexkit/common-auth/opencode2';
+import { type NativeAnthropicAdapterDeps, type NativeAnthropicAttemptData } from './adapter';
+export interface NativeAnthropicInstallation<Q, P> {
+    readonly installation: OpenCode2AuthInstallation<Q, NativeAnthropicAttemptData<P>>;
+    readonly forgetSession: (sessionID: string) => void;
+    readonly dispose: () => Promise<void>;
+}
+/**
+ * The shared installer removes request records on session deletion. Also cancel
+ * the adapter's pending credential lookup and body preparation: removing a
+ * record alone cannot stop an asynchronous callback from returning a token.
+ */
+export declare function installNativeAnthropic<Q, P>(ctx: OpenCode2HookContext, deps: NativeAnthropicAdapterDeps<Q, P>, ownership: NonNullable<InstallOpenCode2AuthOptions['gateOnPlaceholder']>): Promise<NativeAnthropicInstallation<Q, P>>;

package/dist/v2/lifecycle.d.ts

@@ -0,0 +1,8 @@
+import { type NativeAccountRuntime } from '@cortexkit/anthropic-auth-core';
+/**
+ * Background quota and profile reads obtain their own account credentials.
+ * They must not inherit the model policy of the latest user request.
+ */
+export declare function startNativeAnthropicLifecycle(runtime: NativeAccountRuntime, fetchImpl?: typeof fetch): {
+    dispose(): Promise<void>;
+};

package/dist/v2/menu-contract.d.ts

@@ -0,0 +1,8 @@
+import type { NativeMenuCommandId, NativeMenuDispatch } from '@cortexkit/anthropic-auth-core';
+/** Account, setting and session actions exposed through the server's menu RPC. */
+export interface NativeMenuCapabilities {
+    readonly dispatch: NativeMenuDispatch;
+    readonly readStatus: (command: Exclude<NativeMenuCommandId, 'start'>) => Promise<string>;
+    readonly forgetSession: (sessionID: string) => void;
+    readonly close: () => void;
+}

package/dist/v2/menu.d.ts

@@ -0,0 +1,10 @@
+import { type NativeAccountRuntime } from '@cortexkit/anthropic-auth-core';
+import type { NativeMenuCapabilities } from './menu-contract';
+import type { NativeSource } from './source';
+export type { NativeMenuCapabilities } from './menu-contract';
+/** Account and setting changes use the same Core runtime as model requests. */
+export declare function createNativeMenuCapabilities(options: {
+    readonly runtime: NativeAccountRuntime;
+    readonly source: NativeSource;
+    readonly start: (sessionID: string, text: string) => Promise<void>;
+}): NativeMenuCapabilities;

package/dist/v2/models.d.ts

@@ -0,0 +1,6 @@
+import type { Plugin } from '@opencode/plugin';
+/** Each model variant supplies request settings for adaptive thinking and its selected reasoning effort. */
+export declare function createNativeClaudeModelRules(): {
+    install: (ctx: Pick<Plugin.Context, 'model'>) => Promise<import("@opencode/plugin/promise/registration").Registration>;
+    modelId: (id: string) => string;
+};

package/dist/v2/ownership.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Read the credential OpenCode attached to this request: the bearer token, or
+ * else the API key. When a user signs in through this plugin (Claude pool
+ * login or vault activation), OpenCode stores a fixed, non-secret placeholder
+ * string instead of a real token: placeholderSecret('anthropic') from
+ * @cortexkit/common-auth. The request hooks that installOpenCode2Auth installs
+ * serve a request from the plugin's own accounts only when this value equals
+ * that placeholder exactly. Any real token or key, whether from OpenCode's own
+ * login, a configured API key or an environment variable, is left untouched.
+ */
+export declare function preparedAnthropicCredential(headers: Headers): string | undefined;

package/dist/v2/prime.d.ts

@@ -0,0 +1,12 @@
+import { type NativeAccountRuntime, type NativePoolPaths, PrimeManager } from '@cortexkit/anthropic-auth-core';
+import type { NativeSource } from './source';
+/** After the five-hour quota resets, send one minimal authenticated request to start its next window and record that request's token usage. */
+export declare function createNativePrime(options: {
+    runtime: NativeAccountRuntime;
+    paths: NativePoolPaths;
+    source: NativeSource;
+    fetch?: typeof fetch;
+}): {
+    manager: PrimeManager;
+    dispose(): Promise<void>;
+};