@poe-platform/safe-bash 0.1.799 → 0.1.801

package/dist/safe-bash-mcp/index.browser.d.ts

@@ -246,12 +246,12 @@ interface CreateSecretStoreInput {
     keychainStore?: KeychainStoreInput;
 }
 
-type OAuthMetadataFetch = (input: string | URL, init?: RequestInit) => Promise<Response>;
-interface OAuthProtectedResourceMetadata extends Record<string, unknown> {
+type OAuthMetadataFetch$1 = (input: string | URL, init?: RequestInit) => Promise<Response>;
+interface OAuthProtectedResourceMetadata$1 extends Record<string, unknown> {
     resource: string;
     authorization_servers: string[];
 }
-interface OAuthAuthorizationServerMetadata extends Record<string, unknown> {
+interface OAuthAuthorizationServerMetadata$1 extends Record<string, unknown> {
     issuer: string;
     authorization_endpoint: string;
     token_endpoint: string;
@@ -260,13 +260,13 @@ interface OAuthAuthorizationServerMetadata extends Record<string, unknown> {
     code_challenge_methods_supported: string[];
     authorization_response_iss_parameter_supported?: boolean;
 }
-interface OAuthDiscoveryResult {
+interface OAuthDiscoveryResult$1 {
     resource: string;
     resourceMetadataUrl: string;
-    resourceMetadata: OAuthProtectedResourceMetadata;
+    resourceMetadata: OAuthProtectedResourceMetadata$1;
     authorizationServer: string;
     authorizationServerMetadataUrl: string;
-    authorizationServerMetadata: OAuthAuthorizationServerMetadata;
+    authorizationServerMetadata: OAuthAuthorizationServerMetadata$1;
 }
 interface OAuthUnauthorizedChallenge {
     scheme: "Bearer";
@@ -277,31 +277,31 @@ interface OAuthClientProvider {
     /** Establish a grant explicitly, including when resource initialization is public. */
     authenticate?(input: {
         requestUrl: URL;
-        fetch: OAuthMetadataFetch;
+        fetch: OAuthMetadataFetch$1;
         /** Lazy validated discovery. Without it, recover/reuse known grants only. */
-        discover?: () => Promise<OAuthDiscoveryResult>;
+        discover?: () => Promise<OAuthDiscoveryResult$1>;
         signal?: AbortSignal;
-    }): Promise<StoredOAuthTokens | void>;
+    }): Promise<StoredOAuthTokens$1 | void>;
     authorizeRequest?(input: {
         requestUrl: URL;
         headers: Headers;
-        fetch: OAuthMetadataFetch;
+        fetch: OAuthMetadataFetch$1;
         signal?: AbortSignal;
-    }): Promise<StoredOAuthTokens | void> | StoredOAuthTokens | void;
+    }): Promise<StoredOAuthTokens$1 | void> | StoredOAuthTokens$1 | void;
     handleUnauthorized(input: {
         requestUrl: URL;
         response: Response;
         challenge: OAuthUnauthorizedChallenge | null;
         /** Validated metadata supplied by direct callers, if already available. */
-        discovery?: OAuthDiscoveryResult;
+        discovery?: OAuthDiscoveryResult$1;
         /** Lazy validated metadata; invoke only when OAuth recovery needs it. */
-        discover?: () => Promise<OAuthDiscoveryResult>;
-        fetch: OAuthMetadataFetch;
+        discover?: () => Promise<OAuthDiscoveryResult$1>;
+        fetch: OAuthMetadataFetch$1;
         signal?: AbortSignal;
         /** Headers actually attached to this rejected request. */
         requestHeaders?: Headers;
         /** Owned snapshot returned when this request was authorized, or null if absent. */
-        presentedTokens?: StoredOAuthTokens | null;
+        presentedTokens?: StoredOAuthTokens$1 | null;
     }): Promise<{
         action: "retry";
     } | {
@@ -320,7 +320,7 @@ interface OAuthClientMetadata {
     softwareId?: string;
     softwareVersion?: string;
 }
-interface StoredOAuthTokens {
+interface StoredOAuthTokens$1 {
     accessToken: string;
     refreshToken?: string;
     tokenType: "Bearer";
@@ -328,7 +328,7 @@ interface StoredOAuthTokens {
     scope?: string;
 }
 /** Import-time lifetimes are normalized once into persisted epoch milliseconds. */
-interface ImportedOAuthTokens extends Omit<StoredOAuthTokens, "expiresAt"> {
+interface ImportedOAuthTokens extends Omit<StoredOAuthTokens$1, "expiresAt"> {
     expiresAt?: number | null;
     /** Remaining lifetime at import, or total lifetime when issuedAt is provided. */
     expiresIn?: number;
@@ -336,7 +336,7 @@ interface ImportedOAuthTokens extends Omit<StoredOAuthTokens, "expiresAt"> {
     issuedAt?: number;
 }
 /** Full RFC 7591 response, including JSON provider extensions. */
-interface OAuthClientRegistration extends Record<string, unknown> {
+interface OAuthClientRegistration$1 extends Record<string, unknown> {
     client_id: string;
     client_secret?: string | null;
     redirect_uris?: string[] | null;
@@ -347,22 +347,22 @@ interface OAuthClientRegistration extends Record<string, unknown> {
     client_secret_expires_at?: number | null;
     token_endpoint_auth_method?: string | null;
 }
-interface StoredOAuthClient {
+interface StoredOAuthClient$1 {
     clientId: string;
     /** Externally registered apps must never be replaced by native DCR on reload. */
     registrationOwnership?: "caller";
     /** Actual listener URI submitted when this native client was registered. */
     requestedRedirectUri?: string;
     clientSecret?: string;
-    registration?: OAuthClientRegistration;
-    tokenEndpointAuthMethod?: OAuthTokenEndpointAuthMethod;
+    registration?: OAuthClientRegistration$1;
+    tokenEndpointAuthMethod?: OAuthTokenEndpointAuthMethod$1;
 }
-type OAuthTokenEndpointAuthMethod = "none" | "client_secret_post" | "client_secret_basic";
-interface StoredOAuthSession {
+type OAuthTokenEndpointAuthMethod$1 = "none" | "client_secret_post" | "client_secret_basic";
+interface StoredOAuthSession$1 {
     resource: string;
     authorizationServer: string;
-    client: StoredOAuthClient;
-    tokens?: StoredOAuthTokens;
+    client: StoredOAuthClient$1;
+    tokens?: StoredOAuthTokens$1;
     /** A refresh was begun; its winning response may not have been persisted. */
     refreshState?: "pending";
     /** Canonical explicitly requested scope set when the server omits token scope. */
@@ -374,8 +374,8 @@ interface StoredOAuthSession {
     };
 }
 interface OAuthSessionStore {
-    load(resource: string): Promise<StoredOAuthSession | null>;
-    save(resource: string, session: StoredOAuthSession): Promise<void>;
+    load(resource: string): Promise<StoredOAuthSession$1 | null>;
+    save(resource: string, session: StoredOAuthSession$1): Promise<void>;
     clear(resource: string): Promise<void>;
     /** Backend-wide lock covering a complete read/redeem/write transaction. */
     withLock?<T>(resource: string, operation: () => Promise<T>, options: {
@@ -391,15 +391,15 @@ interface DefaultOAuthClientProviderOptions {
         clientSecret?: string;
         metadata?: OAuthClientMetadata;
         /** Import a complete registration owned by the caller. */
-        registration?: OAuthClientRegistration;
-        tokenEndpointAuthMethod?: OAuthTokenEndpointAuthMethod;
+        registration?: OAuthClientRegistration$1;
+        tokenEndpointAuthMethod?: OAuthTokenEndpointAuthMethod$1;
     } | {
         mode: "static";
         clientId: string;
         clientSecret?: string;
         metadata?: OAuthClientMetadata;
-        registration?: OAuthClientRegistration;
-        tokenEndpointAuthMethod?: OAuthTokenEndpointAuthMethod;
+        registration?: OAuthClientRegistration$1;
+        tokenEndpointAuthMethod?: OAuthTokenEndpointAuthMethod$1;
     };
     /** Disable interactive authorization while allowing cached tokens and silent refresh. */
     allowInteractive?: boolean;
@@ -416,6 +416,12 @@ interface DefaultOAuthClientProviderOptions {
     };
     browser: {
         openBrowser?(url: string): Promise<void>;
+        /** Return the full hosted HTTPS callback URL; the client validates redirect, state and issuer. */
+        waitForCallback?(request: {
+            authorizationUrl: string;
+            redirectUri: string;
+            signal: AbortSignal;
+        }): Promise<string>;
         /** Exact registered HTTP loopback redirect URI. */
         redirectUri?: string;
         signal?: AbortSignal;
@@ -436,8 +442,8 @@ type OAuthClientProviderOptions = {
 } | DefaultOAuthClientProviderOptions;
 
 interface OAuthDiscoveryCache {
-    get(resourceUrl: string): OAuthDiscoveryResult | null | undefined | Promise<OAuthDiscoveryResult | null | undefined>;
-    set(resourceUrl: string, value: OAuthDiscoveryResult): void | Promise<void>;
+    get(resourceUrl: string): OAuthDiscoveryResult$1 | null | undefined | Promise<OAuthDiscoveryResult$1 | null | undefined>;
+    set(resourceUrl: string, value: OAuthDiscoveryResult$1): void | Promise<void>;
     delete?(resourceUrl: string): void | Promise<void>;
 }
 
@@ -871,5 +877,125 @@ type RemoteMcpResourceResult = Awaited<ReturnType<McpClient["listResources"]>> |
 /** Access a remote resource directly, preserving one page/result without tool discovery. */
 declare function accessRemoteMcpResources(server: RemoteMcpServer, request: RemoteMcpResourceRequest, options?: RemoteMcpResourceOptions): Promise<RemoteMcpResourceResult>;
 
-export { accessRemoteMcpResources, compileToolArguments, createRemoteMcpCommands, fetchRemoteMcpSchema, remoteMcpCommands, resolveRemoteMcpSchemas };
-export type { RemoteMcpCommandOptions, RemoteMcpElicitationContext, RemoteMcpElicitationHandler, RemoteMcpResourceOptions, RemoteMcpResourceRequest, RemoteMcpResourceResult, RemoteMcpSchema, RemoteMcpServer, SchemaFetchOptions, ToolArgumentParseOptions, ToolArgumentParser, ToolParameter };
+type OAuthMetadataFetch = (input: string | URL, init?: RequestInit) => Promise<Response>;
+interface OAuthProtectedResourceMetadata extends Record<string, unknown> {
+    resource: string;
+    authorization_servers: string[];
+}
+interface OAuthAuthorizationServerMetadata extends Record<string, unknown> {
+    issuer: string;
+    authorization_endpoint: string;
+    token_endpoint: string;
+    registration_endpoint?: string;
+    response_types_supported: string[];
+    code_challenge_methods_supported: string[];
+    authorization_response_iss_parameter_supported?: boolean;
+}
+interface OAuthDiscoveryResult {
+    resource: string;
+    resourceMetadataUrl: string;
+    resourceMetadata: OAuthProtectedResourceMetadata;
+    authorizationServer: string;
+    authorizationServerMetadataUrl: string;
+    authorizationServerMetadata: OAuthAuthorizationServerMetadata;
+}
+interface StoredOAuthTokens {
+    accessToken: string;
+    refreshToken?: string;
+    tokenType: "Bearer";
+    expiresAt: number | null;
+    scope?: string;
+}
+/** Full RFC 7591 response, including JSON provider extensions. */
+interface OAuthClientRegistration extends Record<string, unknown> {
+    client_id: string;
+    client_secret?: string | null;
+    redirect_uris?: string[] | null;
+    grant_types?: string[] | null;
+    response_types?: string[] | null;
+    contacts?: string[] | null;
+    client_id_issued_at?: number | null;
+    client_secret_expires_at?: number | null;
+    token_endpoint_auth_method?: string | null;
+}
+interface StoredOAuthClient {
+    clientId: string;
+    /** Externally registered apps must never be replaced by native DCR on reload. */
+    registrationOwnership?: "caller";
+    /** Actual listener URI submitted when this native client was registered. */
+    requestedRedirectUri?: string;
+    clientSecret?: string;
+    registration?: OAuthClientRegistration;
+    tokenEndpointAuthMethod?: OAuthTokenEndpointAuthMethod;
+}
+type OAuthTokenEndpointAuthMethod = "none" | "client_secret_post" | "client_secret_basic";
+interface StoredOAuthSession {
+    resource: string;
+    authorizationServer: string;
+    client: StoredOAuthClient;
+    tokens?: StoredOAuthTokens;
+    /** A refresh was begun; its winning response may not have been persisted. */
+    refreshState?: "pending";
+    /** Canonical explicitly requested scope set when the server omits token scope. */
+    requestedScope?: string;
+    discovery: {
+        resourceMetadataUrl: string;
+        resourceMetadata: Record<string, unknown>;
+        authorizationServerMetadata: Record<string, unknown>;
+    };
+}
+
+/** Sensitive, JSON-serializable record. Store only in private, authenticated host storage. */
+interface RemoteMcpAuthorizationTransaction {
+    readonly state: string;
+    readonly expiresAt: number;
+    readonly redirectUri: string;
+    readonly codeVerifier: string;
+    readonly requireIssuer: boolean;
+    readonly session: StoredOAuthSession;
+}
+/** Bind each store instance to the authenticated user and logical server. */
+interface RemoteMcpAuthorizationStore {
+    /** Atomically insert a unique state and capture the current credential generation. Never overwrite a state. */
+    create(transaction: RemoteMcpAuthorizationTransaction): Promise<void>;
+    /** Atomically remove/mark consumed, returning at most once across all workers. Preserve the commit fence. */
+    consume(state: string): Promise<RemoteMcpAuthorizationTransaction | null>;
+    /** Atomically persist only if the consumed transaction's generation is still current.
+     * Reset, deletion, reconfiguration and a superseding grant must invalidate the fence.
+     * Return false if stale. Never implement as an unconditional credential save.
+     */
+    commit(transaction: RemoteMcpAuthorizationTransaction, session: StoredOAuthSession): Promise<boolean>;
+}
+interface BeginRemoteMcpAuthorizationOptions {
+    readonly resource: string;
+    readonly redirectUri: string;
+    readonly client: StoredOAuthClient;
+    readonly scope?: string;
+    readonly store: RemoteMcpAuthorizationStore;
+    /** Host-validated discovery, including issuer trust and network policy. No implicit network access. */
+    readonly discover: (resource: string, signal?: AbortSignal) => Promise<OAuthDiscoveryResult>;
+    readonly signal?: AbortSignal;
+    readonly now?: () => number;
+    /** Transaction lifetime, at most ten minutes. */
+    readonly ttlMs?: number;
+}
+interface CompleteRemoteMcpAuthorizationOptions {
+    readonly callbackUrl: string;
+    readonly store: RemoteMcpAuthorizationStore;
+    /** Required host network policy. Redirects are rejected, including at the token endpoint. */
+    readonly fetch: OAuthMetadataFetch;
+    readonly signal?: AbortSignal;
+    readonly now?: () => number;
+}
+/** Start consent without a listener or a pending callback promise. Only the URL leaves private storage. */
+declare function beginRemoteMcpAuthorization(options: BeginRemoteMcpAuthorizationOptions): Promise<{
+    authorizationUrl: string;
+    expiresAt: number;
+}>;
+/** Redeem once after any process restart, then conditionally persist. Returns no tokens or callback secrets. */
+declare function completeRemoteMcpAuthorization(options: CompleteRemoteMcpAuthorizationOptions): Promise<{
+    resource: string;
+}>;
+
+export { accessRemoteMcpResources, beginRemoteMcpAuthorization, compileToolArguments, completeRemoteMcpAuthorization, createRemoteMcpCommands, fetchRemoteMcpSchema, remoteMcpCommands, resolveRemoteMcpSchemas };
+export type { BeginRemoteMcpAuthorizationOptions, CompleteRemoteMcpAuthorizationOptions, RemoteMcpAuthorizationStore, RemoteMcpAuthorizationTransaction, RemoteMcpCommandOptions, RemoteMcpElicitationContext, RemoteMcpElicitationHandler, RemoteMcpResourceOptions, RemoteMcpResourceRequest, RemoteMcpResourceResult, RemoteMcpSchema, RemoteMcpServer, SchemaFetchOptions, ToolArgumentParseOptions, ToolArgumentParser, ToolParameter };