@agentxm/registry-auth 0.28.10 → 0.28.12

package/dist/src/auth-client.d.ts

@@ -1,3 +1,4 @@
+import type { PublishAuthorizationDelivery, PublishAuthorizationPollingStatus } from "@agentxm/registry-protocol/unstable/publish-authorization";
 /**
  * AuthClient Effect service — device flow login, token refresh, revocation, identity queries.
  *
@@ -19,7 +20,7 @@ import { type Handle } from "@agentxm/extension-model/unstable/extensions/handle
 import { type PublishVisibility } from "@agentxm/registry-protocol/unstable/publish/visibility";
 import { type PreviewPublicationSetRequest, type PreviewPublicationSetResponse, type Sha256Hex } from "@agentxm/registry-protocol/unstable/registry/publication-set";
 import { type NormalizedTokenResponse } from "./oauth-contract.js";
-import { RegistryUrl } from "@agentxm/registry-client";
+import { GeneratedRegistryClient, RegistryUrl } from "@agentxm/registry-client";
 import { type AuthError, type StepUpRequest } from "./errors.js";
 export declare const OIDC_LOGIN_SCOPES: readonly ["openid", "profile", "email", "offline_access"];
 export declare const BASELINE_REGISTRY_LOGIN_SCOPES: readonly ["extensions:read", "account:read"];
@@ -102,16 +103,20 @@ export interface ExchangePkceCodeParams {
 }
 export interface CreatePublishAuthorizationRequestParams {
     readonly registryUrl: string;
-    readonly redirectUri: string;
-    readonly state: string;
-    readonly codeChallenge: string;
+    readonly delivery: PublishAuthorizationDelivery;
     readonly publicationSet: PreviewPublicationSetRequest;
 }
 export interface PublishAuthorizationRequestResponse {
+    readonly interval: number;
     readonly requestId: string;
     readonly authorizationUrl: string;
     readonly expiresAt: DateTime.Utc;
 }
+export interface PublishAuthorizationPollingParams {
+    readonly registryUrl: string;
+    readonly requestId: string;
+    readonly initiatorProof: string;
+}
 export interface ExchangePublishAuthorizationCodeParams {
     readonly registryUrl: string;
     readonly code: string;
@@ -156,6 +161,8 @@ export interface AuthClientService {
     readonly getAuthorizationIssuer: () => string;
     readonly exchangePkceCode: (params: ExchangePkceCodeParams) => Effect.Effect<NormalizedTokenResponse, AuthError>;
     readonly createPublishAuthorizationRequest: (params: CreatePublishAuthorizationRequestParams) => Effect.Effect<PublishAuthorizationRequestResponse, AuthError>;
+    readonly pollPublishAuthorization: (params: PublishAuthorizationPollingParams) => Effect.Effect<PublishAuthorizationPollingStatus, AuthError>;
+    readonly exchangePublishAuthorization: (params: PublishAuthorizationPollingParams) => Effect.Effect<PublishAuthorizationExchangeResponse, AuthError>;
     readonly exchangePublishAuthorizationCode: (params: ExchangePublishAuthorizationCodeParams) => Effect.Effect<PublishAuthorizationExchangeResponse, AuthError>;
     readonly initiateDeviceFlow: (options?: LoginScopeOptions) => Effect.Effect<DeviceFlowResponse, AuthError>;
     readonly pollDeviceToken: (deviceCode: string, interval: number) => Effect.Effect<NormalizedTokenResponse, AuthError>;
@@ -167,6 +174,7 @@ export interface AuthClientService {
         readonly limit?: number;
         readonly cursor?: string;
     }) => Effect.Effect<TokenListResponse, AuthError>;
+    readonly getStepUpRequest: (accessToken: string, requestId: string) => Effect.Effect<GeneratedRegistryClient.StepUpRequestStatusResponse, AuthError>;
     readonly waitForStepUpRequest: (accessToken: string, statusUrl: string, intervalSeconds: number) => Effect.Effect<void, AuthError>;
     readonly deleteToken: (accessToken: string, tokenId: string, options?: DeleteTokenOptions) => Effect.Effect<void, AuthError>;
 }

package/dist/src/auth-client.js

@@ -26,7 +26,7 @@ import { normalizeHandle } from "@agentxm/extension-model/unstable/extensions/ha
 import { PublishVisibilitySchema, } from "@agentxm/registry-protocol/unstable/publish/visibility";
 import { PreviewPublicationSetResponseSchema, } from "@agentxm/registry-protocol/unstable/registry/publication-set";
 import {} from "./oauth-contract.js";
-import { GeneratedRegistryClient, RegistryUrl, captureRegistryErrorResponseBodies, getString, isHttpClientError, isRegistryClientError, isRegistryClientFailure, isTransientHttpClientError, mapRegistryFailure, } from "@agentxm/registry-client";
+import { GeneratedRegistryClient, executeRegistryRequest, RegistryUrl, captureRegistryErrorResponseBodies, getString, isHttpClientError, isRegistryClientError, isRegistryClientFailure, isTransientHttpClientError, mapRegistryFailure, } from "@agentxm/registry-client";
 import { AuthExchangeFailed, DeviceLoginCodeExpired, DeviceLoginDenied, RegistryAuthFailed, StepUpRequired, } from "./errors.js";
 // -----------------------------------------------------------------------------
 // Constants
@@ -93,22 +93,44 @@ const PublishAuthorizationExchangeResponseSchema = Schema.Union([
         grants: Schema.Tuple([]),
     }),
 ]);
+const decodePublishAuthorizationExchange = Effect.fn("AuthClient.decodePublishAuthorizationExchange")(function* (registryUrl, response) {
+    if (!Schema.is(PublishAuthorizationExchangeResponseSchema)(response)) {
+        return yield* mapRegistryAuthError(registryUrl, "The Registry is incompatible with exact publish authorization", new Error("Invalid publish capability response"));
+    }
+    if (response.status === "blocked") {
+        return response;
+    }
+    return {
+        status: "admitted",
+        preview: response.preview,
+        grants: response.grants.map((grant) => ({
+            accessToken: grant.access_token,
+            expiresAt: grant.expires_at,
+            scope: grant.scope,
+            publishRequestId: grant.publish_request_id,
+            visibilityContract: grant.visibility_contract,
+            visibility: grant.visibility,
+            condition: grant.condition,
+            publicationSetDigest: grant.publication_set_digest,
+            publicationDescriptorDigest: grant.publication_descriptor_digest,
+        })),
+    };
+});
 const deriveAuthorizationOrigin = (registryUrl) => {
     const url = new URL(registryUrl);
     if (url.origin === "https://registry.agentxm.ai") {
         return "https://agentxm.ai";
     }
-    if (url.origin === "https://registry-dev.agentxm-ai.workers.dev") {
-        return "https://web-dev.agentxm-ai.workers.dev";
-    }
-    if (url.host === "localhost:4300") {
-        return "http://localhost:4200";
+    if (url.origin === "https://registry-dev.agentxm.ai") {
+        return "https://web-dev.agentxm.ai";
     }
-    if (url.host === "127.0.0.1:4300") {
-        return "http://127.0.0.1:4200";
-    }
-    if (url.hostname === "127.0.0.1") {
-        return `${url.protocol}//${url.hostname}:4200`;
+    const localHosts = ["localhost", "127.0.0.1", "[::1]"];
+    const registryPort = Number(url.port);
+    if (localHosts.some((host) => host === url.hostname) &&
+        Number.isInteger(registryPort) &&
+        registryPort >= 4300 &&
+        registryPort <= 4399) {
+        return `${url.protocol}//${url.hostname}:${String(registryPort - 100)}`;
     }
     return url.origin;
 };
@@ -298,24 +320,54 @@ export const AuthClientLive = Layer.effect(AuthClient, Effect.gen(function* () {
     const createPublishAuthorizationRequest = Effect.fn("AuthClient.createPublishAuthorizationRequest")(function* (params) {
         const publishClient = makeGeneratedAuthClient(httpClient, params.registryUrl);
         const publicationSet = yield* Schema.encodeUnknownEffect(GeneratedRegistryClient.PreviewPublicationSetRequest)(params.publicationSet).pipe(Effect.mapError((error) => mapRegistryAuthError(params.registryUrl, "Could not encode publish authorization request", error)));
-        const response = yield* publishClient
-            .AuthCreatePublishAuthorizationRequest({
+        const response = yield* executeRegistryRequest(publishClient.AuthCreatePublishAuthorizationRequest({
             payload: {
                 client_id: CLIENT_ID,
-                redirect_uri: params.redirectUri,
-                state: params.state,
-                code_challenge: params.codeChallenge,
-                code_challenge_method: "S256",
+                delivery: params.delivery,
                 publication_set: publicationSet,
             },
-        })
-            .pipe(Effect.mapError((error) => mapRegistryAuthError(params.registryUrl, "Could not create publish authorization request", error)));
+        }), {
+            operation: "createPublishAuthorizationRequest",
+            request: {
+                service: "registry",
+                method: "POST",
+                url: `${params.registryUrl.replace(/\/+$/, "")}/v1/auth/publish-requests`,
+            },
+            replaySafety: { kind: "mutation" },
+            mapError: (error) => mapRegistryAuthError(params.registryUrl, "Could not create publish authorization request; no automatic replacement was attempted", error),
+        });
         return {
+            interval: response.interval,
             requestId: response.request_id,
             authorizationUrl: response.authorization_url,
             expiresAt: response.expires_at,
         };
     });
+    const pollPublishAuthorization = Effect.fn("AuthClient.pollPublishAuthorization")(function* (params) {
+        const publishClient = makeGeneratedAuthClient(httpClient, params.registryUrl);
+        const requestRef = `${params.registryUrl.replace(/\/+$/, "")}/v1/auth/publish-requests/${params.requestId}`;
+        return yield* executeRegistryRequest(publishClient.AuthPollPublishAuthorization(params.requestId, {
+            payload: { initiator_proof: params.initiatorProof },
+        }), {
+            operation: "pollPublishAuthorization",
+            request: { service: "registry", method: "POST", url: `${requestRef}/status` },
+            replaySafety: { kind: "safe" },
+            mapError: (error) => mapRegistryAuthError(params.registryUrl, `Could not read publish authorization status. Resume the same command with --authorization-request ${requestRef}`, error),
+        });
+    });
+    const exchangePublishAuthorization = Effect.fn("AuthClient.exchangePublishAuthorization")(function* (params) {
+        const publishClient = makeGeneratedAuthClient(httpClient, params.registryUrl);
+        const requestRef = `${params.registryUrl.replace(/\/+$/, "")}/v1/auth/publish-requests/${params.requestId}`;
+        const response = yield* executeRegistryRequest(publishClient.AuthExchangePublishAuthorization(params.requestId, {
+            payload: { initiator_proof: params.initiatorProof },
+        }), {
+            operation: "exchangePublishAuthorization",
+            request: { service: "registry", method: "POST", url: `${requestRef}/exchange` },
+            replaySafety: { kind: "mutation" },
+            mapError: (error) => mapRegistryAuthError(params.registryUrl, `Publish authorization exchange did not complete. Resume with --authorization-request ${requestRef} to check its status before requesting new consent`, error),
+        });
+        return yield* decodePublishAuthorizationExchange(params.registryUrl, response);
+    });
     const exchangePublishAuthorizationCode = Effect.fn("AuthClient.exchangePublishAuthorizationCode")(function* (params) {
         const publishClient = makeGeneratedAuthClient(httpClient, params.registryUrl);
         const response = yield* publishClient
@@ -345,27 +397,7 @@ export const AuthClientLive = Layer.effect(AuthClient, Effect.gen(function* () {
                 })
                 : mapped;
         }));
-        if (!Schema.is(PublishAuthorizationExchangeResponseSchema)(response)) {
-            return yield* mapRegistryAuthError(params.registryUrl, "The Registry is incompatible with exact publish authorization", response);
-        }
-        if (response.status === "blocked") {
-            return response;
-        }
-        return {
-            status: "admitted",
-            preview: response.preview,
-            grants: response.grants.map((grant) => ({
-                accessToken: grant.access_token,
-                expiresAt: grant.expires_at,
-                scope: grant.scope,
-                publishRequestId: grant.publish_request_id,
-                visibilityContract: grant.visibility_contract,
-                visibility: grant.visibility,
-                condition: grant.condition,
-                publicationSetDigest: grant.publication_set_digest,
-                publicationDescriptorDigest: grant.publication_descriptor_digest,
-            })),
-        };
+        return yield* decodePublishAuthorizationExchange(params.registryUrl, response);
     });
     const initiateDeviceFlow = Effect.fn("AuthClient.initiateDeviceFlow")(function* (options) {
         const response = yield* client
@@ -496,6 +528,9 @@ export const AuthClientLive = Layer.effect(AuthClient, Effect.gen(function* () {
             cursor: decoded.cursor,
         };
     });
+    const getStepUpRequest = (accessToken, requestId) => makeGeneratedAuthClient(httpClient, registryUrl, accessToken)
+        .AuthGetStepUpRequest(requestId, undefined)
+        .pipe(Effect.mapError((error) => mapRegistryAuthError(registryUrl, "Could not read step-up request", error)));
     const waitForStepUpRequest = Effect.fn("AuthClient.waitForStepUpRequest")(function* (accessToken, statusUrl, intervalSeconds) {
         const parsedStatusUrl = new URL(statusUrl);
         const requestId = parsedStatusUrl.pathname.slice(parsedStatusUrl.pathname.lastIndexOf("/") + 1);
@@ -558,6 +593,8 @@ export const AuthClientLive = Layer.effect(AuthClient, Effect.gen(function* () {
         getAuthorizationIssuer,
         exchangePkceCode,
         createPublishAuthorizationRequest,
+        pollPublishAuthorization,
+        exchangePublishAuthorization,
         exchangePublishAuthorizationCode,
         initiateDeviceFlow,
         pollDeviceToken,
@@ -566,6 +603,7 @@ export const AuthClientLive = Layer.effect(AuthClient, Effect.gen(function* () {
         getMe,
         createToken,
         listTokens,
+        getStepUpRequest,
         waitForStepUpRequest,
         deleteToken,
     };
@@ -584,6 +622,8 @@ export const AuthClientTest = (overrides) => Layer.succeed(AuthClient, {
         category: "auth",
         detail: "Not implemented in test",
     })),
+    pollPublishAuthorization: () => Effect.fail(new RegistryAuthFailed({ category: "auth", detail: "Not implemented in test" })),
+    exchangePublishAuthorization: () => Effect.fail(new RegistryAuthFailed({ category: "auth", detail: "Not implemented in test" })),
     exchangePublishAuthorizationCode: () => Effect.fail(new RegistryAuthFailed({
         category: "auth",
         detail: "Not implemented in test",
@@ -613,6 +653,7 @@ export const AuthClientTest = (overrides) => Layer.succeed(AuthClient, {
         category: "auth",
         detail: "Not implemented in test",
     })),
+    getStepUpRequest: () => Effect.fail(new RegistryAuthFailed({ category: "auth", detail: "Not implemented in test" })),
     waitForStepUpRequest: () => Effect.fail(new RegistryAuthFailed({
         category: "auth",
         detail: "Not implemented in test",

package/dist/src/device-login.d.ts

@@ -53,11 +53,15 @@ export declare const DeviceLoginPendingResultSchema: Schema.Struct<{
     readonly interval: Schema.Number;
     readonly resume: Schema.String;
     readonly action: Schema.Struct<{
-        readonly kind: Schema.Literal<"open-url">;
-        readonly url: Schema.String;
+        readonly purpose: Schema.Literal<"login">;
         readonly fallbackUrl: Schema.String;
         readonly code: Schema.String;
+        readonly kind: Schema.Literal<"open-url">;
+        readonly requestRef: Schema.String;
+        readonly registryUrl: Schema.String;
+        readonly url: Schema.String;
         readonly expiresAt: Schema.String;
+        readonly intervalSeconds: Schema.Number;
         readonly resume: Schema.String;
     }>;
 }>;
@@ -77,11 +81,15 @@ export declare const DeviceLoginPendingDocumentSchema: Schema.Struct<{
         readonly interval: Schema.Number;
         readonly resume: Schema.String;
         readonly action: Schema.Struct<{
-            readonly kind: Schema.Literal<"open-url">;
-            readonly url: Schema.String;
+            readonly purpose: Schema.Literal<"login">;
             readonly fallbackUrl: Schema.String;
             readonly code: Schema.String;
+            readonly kind: Schema.Literal<"open-url">;
+            readonly requestRef: Schema.String;
+            readonly registryUrl: Schema.String;
+            readonly url: Schema.String;
             readonly expiresAt: Schema.String;
+            readonly intervalSeconds: Schema.Number;
             readonly resume: Schema.String;
         }>;
     }>;
@@ -100,15 +108,19 @@ export declare const initiateDeviceLogin: (registryUrl: string, options?: RunDev
     readonly interval: number;
     readonly resume: string;
     readonly action: {
-        readonly kind: "open-url";
-        readonly url: string;
+        readonly purpose: "login";
         readonly fallbackUrl: string;
         readonly code: string;
+        readonly kind: "open-url";
+        readonly requestRef: string;
+        readonly registryUrl: string;
+        readonly url: string;
         readonly expiresAt: string;
+        readonly intervalSeconds: number;
         readonly resume: string;
     };
 }, import("./errors.js").AuthError, AuthClient | CredentialStore | AuthLoginPresenter | PendingDeviceLoginStore | DeviceLoginInteraction>;
-export declare const resumeDeviceLogin: (registryUrl: string, options?: ResumeDeviceLoginOptions) => Effect.Effect<undefined, RegistryAuthFailed | import("./errors.js").AuthLoginRequired | import("./errors.js").AuthTokenPolicyRequired | DeviceAuthorizationPending | import("./errors.js").StepUpRequired | import("@agentxm/registry-client").RegistryClientFailure | import("./errors.js").AuthExchangeFailed, AuthClient | CredentialStore | AuthLoginPresenter | PendingDeviceLoginStore>;
-export declare const runDeviceLogin: (registryUrl: string, options?: RunDeviceLoginOptions) => Effect.Effect<void, RegistryAuthFailed | import("./errors.js").AuthLoginRequired | import("./errors.js").AuthTokenPolicyRequired | import("./errors.js").DeviceLoginDenied | import("./errors.js").DeviceLoginCodeExpired | DeviceAuthorizationPending | import("./errors.js").StepUpRequired | import("@agentxm/registry-client").RegistryProblem | import("@agentxm/registry-client").RegistryRequestFailed | import("@agentxm/registry-client").RegistryOperationFailed | import("./errors.js").AuthExchangeFailed, AuthClient | CredentialStore | AuthLoginPresenter | PendingDeviceLoginStore | DeviceLoginInteraction>;
+export declare const resumeDeviceLogin: (registryUrl: string, options?: ResumeDeviceLoginOptions) => Effect.Effect<undefined, RegistryAuthFailed | import("./errors.js").AuthLoginRequired | import("./errors.js").AuthTokenPolicyRequired | DeviceAuthorizationPending | import("./errors.js").StepUpRequired | import("@agentxm/registry-client").RegistryClientFailure | import("./errors.js").AuthExchangeFailed | import("./errors.js").PublishAuthorizationPending, AuthClient | CredentialStore | AuthLoginPresenter | PendingDeviceLoginStore>;
+export declare const runDeviceLogin: (registryUrl: string, options?: RunDeviceLoginOptions) => Effect.Effect<void, RegistryAuthFailed | import("./errors.js").AuthLoginRequired | import("./errors.js").AuthTokenPolicyRequired | import("./errors.js").DeviceLoginDenied | import("./errors.js").DeviceLoginCodeExpired | DeviceAuthorizationPending | import("./errors.js").StepUpRequired | import("@agentxm/registry-client").RegistryProblem | import("@agentxm/registry-client").RegistryRequestFailed | import("@agentxm/registry-client").RegistryOperationFailed | import("./errors.js").AuthExchangeFailed | import("./errors.js").PublishAuthorizationPending, AuthClient | CredentialStore | AuthLoginPresenter | PendingDeviceLoginStore | DeviceLoginInteraction>;
 export {};
 //# sourceMappingURL=device-login.d.ts.map

package/dist/src/device-login.js

@@ -1,3 +1,4 @@
+import { HumanHandoffActionSchema } from "@agentxm/registry-protocol/unstable/human-handoff";
 /**
  * Shared device-code login flow for auth commands and guards.
  *
@@ -58,12 +59,10 @@ const persistLoginCredentials = (registryUrl, token) => Effect.gen(function* ()
     return Option.map(meResult, (me) => me.userHandle);
 });
 const DeviceLoginActionSchema = Schema.Struct({
-    kind: Schema.Literal("open-url"),
-    url: Schema.String,
+    ...HumanHandoffActionSchema.fields,
+    purpose: Schema.Literal("login"),
     fallbackUrl: Schema.String,
     code: Schema.String,
-    expiresAt: Schema.String,
-    resume: Schema.String,
 });
 export const DeviceLoginPendingResultSchema = Schema.Struct({
     status: Schema.Literal("pending-human"),
@@ -119,6 +118,10 @@ const makePendingResult = (pending, flow = "started") => {
         resume,
         action: {
             kind: "open-url",
+            purpose: "login",
+            requestRef: pending.verificationUriComplete,
+            registryUrl: pending.registryUrl,
+            intervalSeconds: pending.interval,
             url: pending.verificationUriComplete,
             fallbackUrl: pending.verificationUri,
             code: pending.userCode,
@@ -258,6 +261,8 @@ export const resumeDeviceLogin = (registryUrl, options = {}) => Effect.gen(funct
                 const action = makePendingResult(pending).action;
                 return Effect.fail(new DeviceAuthorizationPending({
                     timeoutSeconds,
+                    registryUrl: pending.registryUrl,
+                    intervalSeconds: pending.interval,
                     verificationUri: action.fallbackUrl,
                     verificationUriComplete: action.url,
                     userCode: action.code,

package/dist/src/errors.d.ts

@@ -1,13 +1,4 @@
-/**
- * Typed failures for the registry-auth feature. The producer owns the
- * category choice and user-facing wording; the application boundary converts
- * the carried fields into its error envelope verbatim. Failures that carry a
- * registry transport failure keep it intact so the boundary can restore the
- * exact evidence, metadata, and semantics the former in-place conversion
- * produced.
- *
- * @experimental This API is unstable and may change without notice.
- */
+import type { HumanHandoffAction } from "@agentxm/registry-protocol/unstable/human-handoff";
 import { type RegistryClientFailure } from "@agentxm/registry-client";
 import type { SuggestedAction } from "@agentxm/registry-protocol/unstable/suggested-action";
 /** Every category a registry-auth failure can carry. Identical strings to the CLI error codes. */
@@ -80,6 +71,8 @@ declare const DeviceAuthorizationPending_base: new <A extends Record<string, any
  */
 export declare class DeviceAuthorizationPending extends DeviceAuthorizationPending_base<{
     readonly timeoutSeconds: number;
+    readonly registryUrl: string;
+    readonly intervalSeconds: number;
     readonly verificationUri: string;
     readonly verificationUriComplete: string;
     readonly userCode: string;
@@ -128,8 +121,16 @@ export declare class AuthExchangeFailed extends AuthExchangeFailed_base<{
     readonly failure: RegistryClientFailure;
 }> {
 }
+declare const PublishAuthorizationPending_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "PublishAuthorizationPending";
+} & Readonly<A>;
+export declare class PublishAuthorizationPending extends PublishAuthorizationPending_base<{
+    readonly action: HumanHandoffAction;
+    readonly timedOut: boolean;
+}> {
+}
 /** Every typed failure the registry-auth feature constructs. */
-export type RegistryAuthFailure = RegistryAuthFailed | AuthLoginRequired | AuthTokenPolicyRequired | DeviceLoginDenied | DeviceLoginCodeExpired | DeviceAuthorizationPending | StepUpRequired | AuthExchangeFailed;
+export type RegistryAuthFailure = RegistryAuthFailed | AuthLoginRequired | AuthTokenPolicyRequired | DeviceLoginDenied | DeviceLoginCodeExpired | DeviceAuthorizationPending | PublishAuthorizationPending | StepUpRequired | AuthExchangeFailed;
 export declare const isRegistryAuthFailure: (error: unknown) => error is RegistryAuthFailure;
 /**
  * Every failure a registry-auth use case can surface: the feature's own typed

package/dist/src/errors.js

@@ -72,12 +72,15 @@ export class StepUpRequired extends Data.TaggedError("StepUpRequired") {
  */
 export class AuthExchangeFailed extends Data.TaggedError("AuthExchangeFailed") {
 }
+export class PublishAuthorizationPending extends Data.TaggedError("PublishAuthorizationPending") {
+}
 export const isRegistryAuthFailure = (error) => error instanceof RegistryAuthFailed ||
     error instanceof AuthLoginRequired ||
     error instanceof AuthTokenPolicyRequired ||
     error instanceof DeviceLoginDenied ||
     error instanceof DeviceLoginCodeExpired ||
     error instanceof DeviceAuthorizationPending ||
+    error instanceof PublishAuthorizationPending ||
     error instanceof StepUpRequired ||
     error instanceof AuthExchangeFailed;
 export const isAuthError = (error) => isRegistryAuthFailure(error) || isRegistryClientFailure(error);

package/dist/src/index.d.ts

@@ -10,7 +10,7 @@
  * @experimental This API is unstable and may change without notice.
  * @packageDocumentation
  */
-export { AuthExchangeFailed, AuthLoginRequired, AuthTokenPolicyRequired, authLoginRequired, DeviceAuthorizationPending, DeviceLoginCodeExpired, DeviceLoginDenied, isAuthError, isRegistryAuthFailure, REGISTRY_AUTH_ERROR_CATEGORIES, RegistryAuthFailed, StepUpRequired, type AuthError, type RegistryAuthErrorCategory, type RegistryAuthFailure, type StepUpRequest, } from "./errors.js";
+export { AuthExchangeFailed, AuthLoginRequired, AuthTokenPolicyRequired, authLoginRequired, DeviceAuthorizationPending, PublishAuthorizationPending, DeviceLoginCodeExpired, DeviceLoginDenied, isAuthError, isRegistryAuthFailure, REGISTRY_AUTH_ERROR_CATEGORIES, RegistryAuthFailed, StepUpRequired, type AuthError, type RegistryAuthErrorCategory, type RegistryAuthFailure, type StepUpRequest, } from "./errors.js";
 export type { CredentialEntry, CredentialFile, StorageTier, StoredCredentials, TokenSource, } from "./schema.js";
 export { CredentialEntrySchema, CredentialFileSchema, CredentialStoreTokenSource, EnvVarTokenSource, FileTokenSource, FlagTokenSource, RegistryAccountsSchema, } from "./schema.js";
 export type { CredentialStoreService, EnvironmentInfo } from "./credential-store.js";
@@ -18,7 +18,7 @@ export { canUsePersistedCredentials, CredentialStore, detectEnvironment, makePer
 export type { PendingDeviceLogin, PendingDeviceLoginStoreService, } from "./pending-device-login-store.js";
 export { PendingDeviceLoginSchema, PendingDeviceLoginStore } from "./pending-device-login-store.js";
 export { getCurrentUserHandle, resolveRequiredToken, resolveToken, resolveStoredToken, refreshStoredToken, resolveAmbientToken, resolveRequestToken, } from "./token-resolution.js";
-export type { AuthClientService, CreateTokenOptions, CreatePublishAuthorizationRequestParams, DeviceFlowResponse, ExchangePublishAuthorizationCodeParams, MeResponse, PollResult, PublishAuthorizationRequestResponse, PublishCapabilityResponse, } from "./auth-client.js";
+export type { AuthClientService, CreateTokenOptions, CreatePublishAuthorizationRequestParams, DeviceFlowResponse, ExchangePublishAuthorizationCodeParams, MeResponse, PollResult, PublishAuthorizationRequestResponse, PublishAuthorizationExchangeResponse, PublishCapabilityResponse, } from "./auth-client.js";
 export { AuthClient, pollOnce, readStepUpRequest } from "./auth-client.js";
 export type { NormalizedTokenResponse } from "./oauth-contract.js";
 export type { DeviceLoginPendingResult, DeviceLoginInteractionService, ResumeDeviceLoginOptions, } from "./device-login.js";
@@ -33,4 +33,5 @@ export { selectLoginStrategy, type LoginStrategy, type LoginStrategyEnvironment,
 export type { AuthLoginInteractionService } from "./login-interaction.js";
 export { AuthLoginInteraction } from "./login-interaction.js";
 export { withAuthGuard } from "./guard.js";
+export { PendingPublishAuthorizationStore, PendingPublishAuthorizationSchema, type PendingPublishAuthorization, type PendingPublishAuthorizationStoreService, } from "./pending-publish-authorization-store.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/src/index.js

@@ -11,7 +11,7 @@
  * @packageDocumentation
  */
 // Typed failures
-export { AuthExchangeFailed, AuthLoginRequired, AuthTokenPolicyRequired, authLoginRequired, DeviceAuthorizationPending, DeviceLoginCodeExpired, DeviceLoginDenied, isAuthError, isRegistryAuthFailure, REGISTRY_AUTH_ERROR_CATEGORIES, RegistryAuthFailed, StepUpRequired, } from "./errors.js";
+export { AuthExchangeFailed, AuthLoginRequired, AuthTokenPolicyRequired, authLoginRequired, DeviceAuthorizationPending, PublishAuthorizationPending, DeviceLoginCodeExpired, DeviceLoginDenied, isAuthError, isRegistryAuthFailure, REGISTRY_AUTH_ERROR_CATEGORIES, RegistryAuthFailed, StepUpRequired, } from "./errors.js";
 export { CredentialEntrySchema, CredentialFileSchema, CredentialStoreTokenSource, EnvVarTokenSource, FileTokenSource, FlagTokenSource, RegistryAccountsSchema, } from "./schema.js";
 export { canUsePersistedCredentials, CredentialStore, detectEnvironment, makePersistedCredentialsUnsupportedError, selectTier, } from "./credential-store.js";
 export { PendingDeviceLoginSchema, PendingDeviceLoginStore } from "./pending-device-login-store.js";
@@ -28,4 +28,5 @@ export { selectLoginStrategy, } from "./login-strategy.js";
 export { AuthLoginInteraction } from "./login-interaction.js";
 // Auth guard combinator
 export { withAuthGuard } from "./guard.js";
+export { PendingPublishAuthorizationStore, PendingPublishAuthorizationSchema, } from "./pending-publish-authorization-store.js";
 //# sourceMappingURL=index.js.map

package/dist/src/live.d.ts

@@ -10,4 +10,5 @@ export { AuthMiddlewareLive, makeAuthMiddlewareLive } from "./auth-middleware.js
 export { CredentialStoreLive, CredentialStoreSessionLive } from "./credential-store.js";
 export { AuthLoginInteractionLive } from "./login-interaction.js";
 export { PendingDeviceLoginStoreLive } from "./pending-device-login-store.js";
+export { PendingPublishAuthorizationStoreLive } from "./pending-publish-authorization-store.js";
 //# sourceMappingURL=live.d.ts.map

package/dist/src/live.js

@@ -10,4 +10,5 @@ export { AuthMiddlewareLive, makeAuthMiddlewareLive } from "./auth-middleware.js
 export { CredentialStoreLive, CredentialStoreSessionLive } from "./credential-store.js";
 export { AuthLoginInteractionLive } from "./login-interaction.js";
 export { PendingDeviceLoginStoreLive } from "./pending-device-login-store.js";
+export { PendingPublishAuthorizationStoreLive } from "./pending-publish-authorization-store.js";
 //# sourceMappingURL=live.js.map

package/dist/src/loopback-login.js

@@ -52,7 +52,7 @@ export const runLoopbackLogin = (registryUrl, options = {}) => Effect.scoped(Eff
     const verifier = makePkceVerifier();
     const challenge = makePkceChallenge(verifier);
     const state = makeOAuthState();
-    const server = yield* startLoopbackServer(state);
+    const server = yield* startLoopbackServer(state, "login");
     const authorizeUrl = authClient.buildAuthorizeUrl({
         challenge,
         expiresAt: DateTime.addDuration(yield* DateTime.now, LOOPBACK_TIMEOUT),
@@ -86,6 +86,7 @@ export const runLoopbackLogin = (registryUrl, options = {}) => Effect.scoped(Eff
         });
         return yield* persistLoginCredentials(registryUrl, token);
     }));
+    yield* server.complete;
     yield* emitLoginSuccess(registryUrl, handle);
 }));
 //# sourceMappingURL=loopback-login.js.map

package/dist/src/loopback-server.d.ts

@@ -29,11 +29,13 @@ export declare class LoopbackCallbackRejected extends LoopbackCallbackRejected_b
 export interface LoopbackServer {
     readonly port: number;
     readonly redirectUri: string;
+    readonly complete: Effect.Effect<void>;
     readonly awaitCallback: (timeoutMs: number) => Effect.Effect<LoopbackCallback, LoopbackLoginFallback | LoopbackCallbackRejected>;
 }
-export declare const startLoopbackServer: (expectedState: string) => Effect.Effect<{
+export declare const startLoopbackServer: (expectedState: string, purpose: "login" | "publish") => Effect.Effect<{
     port: number;
     redirectUri: string;
+    complete: Effect.Effect<void, never, never>;
     awaitCallback: (timeoutMs: number) => Effect.Effect<LoopbackCallback, LoopbackLoginFallback | LoopbackCallbackRejected, never>;
 }, LoopbackLoginFallback, import("effect/Scope").Scope>;
 export {};

package/dist/src/loopback-server.js

@@ -7,14 +7,14 @@ import * as Data from "effect/Data";
 import * as Deferred from "effect/Deferred";
 import * as Duration from "effect/Duration";
 import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
 export class LoopbackLoginFallback extends Data.TaggedError("LoopbackLoginFallback") {
 }
 export class LoopbackCallbackRejected extends Data.TaggedError("LoopbackCallbackRejected") {
 }
 const page = (title, content) => `<!doctype html><html><head><meta charset="utf-8"><title>${title}</title></head><body><main style="font-family: system-ui, sans-serif; margin: 3rem auto; max-width: 34rem;"><h1>${title}</h1><p>${content}</p></main></body></html>`;
-const successPage = page("You’re signed in to AgentXM.ai", 'Return to your terminal to continue. You can close this tab. <a href="https://agentxm.ai">AgentXM.ai</a>');
-const cancellationPage = page("Sign-in was cancelled", "No credentials were changed. Return to your terminal to try again.");
-const errorPage = page("AXM sign-in could not be completed", "Return to your terminal for details and recovery instructions.");
+const cancellationPage = page("Authorization was denied", "Return to your terminal for recovery instructions.");
+const errorPage = page("AXM authorization could not be completed", "Return to your terminal for details and recovery instructions.");
 const writeHtml = (response, statusCode, body) => {
     response.writeHead(statusCode, {
         "content-type": "text/html; charset=utf-8",
@@ -79,7 +79,7 @@ const makeCallbackOutcome = (request, expectedState) => {
         callback: { code, state, iss },
     };
 };
-export const startLoopbackServer = (expectedState) => Effect.gen(function* () {
+export const startLoopbackServer = (expectedState, purpose) => Effect.gen(function* () {
     const http = yield* Effect.tryPromise({
         try: () => import("node:http"),
         catch: (cause) => new LoopbackLoginFallback({
@@ -89,16 +89,58 @@ export const startLoopbackServer = (expectedState) => Effect.gen(function* () {
         }),
     });
     const callback = yield* Deferred.make();
+    const browserResponse = yield* Deferred.make();
+    const finish = (completed) => Effect.gen(function* () {
+        const pending = yield* Deferred.poll(browserResponse);
+        if (Option.isNone(pending))
+            return;
+        const response = yield* pending.value;
+        if (response.writableEnded || response.destroyed)
+            return;
+        const title = completed
+            ? purpose === "login"
+                ? "You’re signed in to AgentXM.ai"
+                : "Publish authorization received"
+            : "AXM authorization could not be completed";
+        const content = completed
+            ? purpose === "login"
+                ? "Your credentials have been saved. Return to your terminal to continue. You can close this tab."
+                : "AXM received permission for the reviewed publication. Return to your terminal to check the publish result. You can close this tab."
+            : "Return to your terminal for details and recovery instructions.";
+        yield* Effect.callback((resume) => {
+            const done = () => resume(Effect.void);
+            response.once("close", done);
+            response.end(`<style>#receipt{display:none}</style><section role="status"><h1>${title}</h1><p>${content}</p></section></main></body></html>`, done);
+            return Effect.sync(() => {
+                response.off("close", done);
+            });
+        });
+    });
     const listener = yield* Effect.acquireRelease(Effect.callback((resume) => {
         let acquired = false;
         const server = http.createServer((request, response) => {
+            if (Deferred.isDoneUnsafe(callback)) {
+                writeHtml(response, 409, page("Callback already received", "Return to the original tab or your terminal to check the result."));
+                return;
+            }
             const outcome = makeCallbackOutcome(request, expectedState);
-            writeHtml(response, outcome._tag === "success" ? 200 : 400, outcome._tag === "success"
-                ? successPage
-                : outcome.error._tag === "LoopbackCallbackRejected" &&
+            if (outcome._tag === "success") {
+                response.writeHead(200, {
+                    "content-type": "text/html; charset=utf-8",
+                    "cache-control": "no-store",
+                    "referrer-policy": "no-referrer",
+                    "x-content-type-options": "nosniff",
+                    "content-security-policy": "default-src 'none'; style-src 'unsafe-inline'; frame-ancestors 'none'",
+                });
+                response.write('<!doctype html><html><head><meta charset="utf-8"><meta name="viewport" content="width=device-width, initial-scale=1"><title>AXM authorization</title></head><body><main style="font-family:system-ui,sans-serif;margin:3rem auto;max-width:34rem;padding:1rem"><section id="receipt" role="status"><h1>Callback received</h1><p>AXM is finishing authorization. Check your terminal if this page stops updating.</p></section>');
+                Deferred.doneUnsafe(browserResponse, Effect.succeed(response));
+            }
+            else {
+                writeHtml(response, 400, outcome.error._tag === "LoopbackCallbackRejected" &&
                     outcome.error.reason === "access_denied"
                     ? cancellationPage
                     : errorPage);
+            }
             Deferred.doneUnsafe(callback, outcome._tag === "success"
                 ? Effect.succeed(outcome.callback)
                 : Effect.fail(outcome.error));
@@ -146,6 +188,7 @@ export const startLoopbackServer = (expectedState) => Effect.gen(function* () {
         },
         catch: () => undefined,
     }).pipe(Effect.ignore));
+    yield* Effect.addFinalizer(() => finish(false));
     listener.server.on("error", (cause) => {
         Deferred.doneUnsafe(callback, Effect.fail(new LoopbackLoginFallback({
             reason: "bind_failed",
@@ -156,6 +199,7 @@ export const startLoopbackServer = (expectedState) => Effect.gen(function* () {
     return {
         port: listener.port,
         redirectUri: `http://127.0.0.1:${listener.port}/callback`,
+        complete: finish(true),
         awaitCallback: (timeoutMs) => Deferred.await(callback).pipe(Effect.timeoutOrElse({
             duration: Duration.millis(timeoutMs),
             orElse: () => Effect.fail(new LoopbackLoginFallback({

package/dist/src/pending-publish-authorization-store.d.ts

@@ -0,0 +1,33 @@
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as FileSystem from "effect/FileSystem";
+import * as Layer from "effect/Layer";
+import * as Option from "effect/Option";
+import * as Path from "effect/Path";
+import * as Schema from "effect/Schema";
+import { RegistryAuthFailed } from "./errors.js";
+export declare const PendingPublishAuthorizationSchema: Schema.Struct<{
+    readonly version: Schema.Literal<1>;
+    readonly purpose: Schema.Literal<"publish">;
+    readonly registryUrl: Schema.String;
+    readonly requestRef: Schema.String;
+    readonly requestId: Schema.String;
+    readonly authorizationUrl: Schema.String;
+    readonly expiresAt: Schema.decodeTo<Schema.DateTimeUtc, Schema.String, never, never>;
+    readonly interval: Schema.Int;
+    readonly publicationSetDigest: Schema.String;
+    readonly initiatorProof: Schema.String;
+}>;
+export type PendingPublishAuthorization = typeof PendingPublishAuthorizationSchema.Type;
+export interface PendingPublishAuthorizationStoreService {
+    readonly save: (pending: PendingPublishAuthorization) => Effect.Effect<void, RegistryAuthFailed>;
+    readonly load: (requestRef: string) => Effect.Effect<Option.Option<PendingPublishAuthorization>, RegistryAuthFailed>;
+    readonly clear: (requestRef: string) => Effect.Effect<void, RegistryAuthFailed>;
+}
+declare const PendingPublishAuthorizationStore_base: Context.ServiceClass<PendingPublishAuthorizationStore, "@agentxm/registry-auth/PendingPublishAuthorizationStore", PendingPublishAuthorizationStoreService>;
+export declare class PendingPublishAuthorizationStore extends PendingPublishAuthorizationStore_base {
+}
+export declare const PendingPublishAuthorizationStoreLive: Layer.Layer<PendingPublishAuthorizationStore, never, FileSystem.FileSystem | Path.Path>;
+export declare const PendingPublishAuthorizationStoreTest: (initial?: ReadonlyArray<PendingPublishAuthorization>) => Layer.Layer<PendingPublishAuthorizationStore, never, never>;
+export {};
+//# sourceMappingURL=pending-publish-authorization-store.d.ts.map

package/dist/src/pending-publish-authorization-store.js

@@ -0,0 +1,90 @@
+import { createHash } from "node:crypto";
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as FileSystem from "effect/FileSystem";
+import * as Layer from "effect/Layer";
+import * as Option from "effect/Option";
+import * as Path from "effect/Path";
+import * as Schema from "effect/Schema";
+import { DateTimeUtcSchema } from "@agentxm/extension-model/unstable/date-time";
+import { RegistryAuthFailed } from "./errors.js";
+import { envOption } from "./internal/environment.js";
+export const PendingPublishAuthorizationSchema = Schema.Struct({
+    version: Schema.Literal(1),
+    purpose: Schema.Literal("publish"),
+    registryUrl: Schema.String,
+    requestRef: Schema.String,
+    requestId: Schema.String,
+    authorizationUrl: Schema.String,
+    expiresAt: DateTimeUtcSchema,
+    interval: Schema.Int.check(Schema.isGreaterThan(0)),
+    publicationSetDigest: Schema.String.check(Schema.isPattern(/^[a-f0-9]{64}$/)),
+    initiatorProof: Schema.String.check(Schema.isPattern(/^[A-Za-z0-9_-]{43,128}$/)),
+});
+export class PendingPublishAuthorizationStore extends Context.Service()("@agentxm/registry-auth/PendingPublishAuthorizationStore") {
+}
+const storageError = (operation) => new RegistryAuthFailed({
+    category: "auth",
+    detail: `Could not ${operation} the private publish authorization record. Its public request URL cannot replace the missing proof.`,
+});
+export const PendingPublishAuthorizationStoreLive = Layer.effect(PendingPublishAuthorizationStore, Effect.gen(function* () {
+    const fs = yield* FileSystem.FileSystem;
+    const path = yield* Path.Path;
+    const homes = [
+        yield* envOption("AXM_USER_HOME"),
+        yield* envOption("HOME"),
+        yield* envOption("USERPROFILE"),
+    ];
+    const home = homes.find(Option.isSome);
+    const storageDirectory = home === undefined
+        ? Effect.fail(storageError("locate"))
+        : Effect.succeed(path.join(home.value, ".axm", "publish-authorizations"));
+    const filename = (directory, reference) => path.join(directory, `${createHash("sha256").update(reference).digest("hex")}.json`);
+    return {
+        save: (pending) => Effect.gen(function* () {
+            const directory = yield* storageDirectory;
+            yield* fs.makeDirectory(directory, { recursive: true, mode: 0o700 });
+            yield* fs.chmod(directory, 0o700);
+            const file = filename(directory, pending.requestRef);
+            const encoded = yield* Schema.encodeEffect(PendingPublishAuthorizationSchema)(pending);
+            yield* Effect.acquireUseRelease(fs.makeTempDirectory({ directory, prefix: "publish-" }), (temporaryDirectory) => Effect.gen(function* () {
+                const temporary = path.join(temporaryDirectory, "proof.json");
+                yield* fs.writeFileString(temporary, JSON.stringify(encoded), {
+                    mode: 0o600,
+                    flag: "wx",
+                });
+                yield* fs.link(temporary, file);
+            }), (temporaryDirectory) => fs
+                .remove(temporaryDirectory, { recursive: true, force: true })
+                .pipe(Effect.catch(() => Effect.void)));
+        }).pipe(Effect.mapError(() => storageError("save"))),
+        load: (reference) => Effect.gen(function* () {
+            const directory = yield* storageDirectory;
+            const file = filename(directory, reference);
+            if (!(yield* fs.exists(file)))
+                return Option.none();
+            const content = yield* fs.readFileString(file);
+            const pending = yield* Schema.decodeUnknownEffect(Schema.fromJsonString(PendingPublishAuthorizationSchema))(content);
+            if (pending.requestRef !== reference)
+                return yield* storageError("validate");
+            return Option.some(pending);
+        }).pipe(Effect.mapError(() => storageError("read"))),
+        clear: (reference) => Effect.gen(function* () {
+            const directory = yield* storageDirectory;
+            yield* fs.remove(filename(directory, reference), { force: true });
+        }).pipe(Effect.mapError(() => storageError("remove"))),
+    };
+}));
+export const PendingPublishAuthorizationStoreTest = (initial = []) => {
+    const records = new Map(initial.map((record) => [record.requestRef, record]));
+    return Layer.succeed(PendingPublishAuthorizationStore, {
+        save: (pending) => Effect.sync(() => {
+            records.set(pending.requestRef, pending);
+        }),
+        load: (reference) => Effect.sync(() => Option.fromNullishOr(records.get(reference))),
+        clear: (reference) => Effect.sync(() => {
+            records.delete(reference);
+        }),
+    });
+};
+//# sourceMappingURL=pending-publish-authorization-store.js.map

package/dist/src/publish-authorization-polling.d.ts

@@ -0,0 +1,13 @@
+import { DeviceLoginInteraction } from "./device-login.js";
+import { AuthLoginPresenter } from "./login-presenter.js";
+import * as Effect from "effect/Effect";
+import { AuthClient, type PublishAuthorizationExchangeResponse } from "./auth-client.js";
+import { RegistryAuthFailed } from "./errors.js";
+import { PendingPublishAuthorizationStore } from "./pending-publish-authorization-store.js";
+import type { PublishAuthorizationInput } from "./publish-authorization.js";
+export declare const readPublishAuthorizationReference: (reference: string, registryUrl: string) => Effect.Effect<{
+    requestId: string;
+    requestRef: string;
+}, RegistryAuthFailed, never>;
+export declare const runPollingPublishAuthorization: (input: PublishAuthorizationInput) => Effect.Effect<PublishAuthorizationExchangeResponse, import("./errors.js").AuthError, AuthClient | AuthLoginPresenter | DeviceLoginInteraction | PendingPublishAuthorizationStore>;
+//# sourceMappingURL=publish-authorization-polling.d.ts.map

package/dist/src/publish-authorization-polling.js

@@ -0,0 +1,176 @@
+import { DeviceLoginInteraction } from "./device-login.js";
+import { AuthLoginPresenter } from "./login-presenter.js";
+import * as DateTime from "effect/DateTime";
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import { publicationSetDigest } from "@agentxm/registry-protocol/unstable/registry/publication-set";
+import { AuthClient } from "./auth-client.js";
+import { PublishAuthorizationPending, RegistryAuthFailed } from "./errors.js";
+import { makePkceChallenge, makePkceVerifier } from "./loopback-login.js";
+import { PendingPublishAuthorizationStore, } from "./pending-publish-authorization-store.js";
+const invalidResume = (detail) => new RegistryAuthFailed({
+    category: "validation",
+    detail,
+    recover: "Resume with the original publication inputs and requestRef. To request new consent, rerun publish without --authorization-request.",
+});
+export const readPublishAuthorizationReference = (reference, registryUrl) => Effect.try({
+    try: () => {
+        const url = new URL(reference);
+        const registry = new URL(registryUrl);
+        const match = /^\/v1\/auth\/publish-requests\/(pubreq_[a-z0-9]{26})$/.exec(url.pathname);
+        if (url.origin !== registry.origin ||
+            url.username ||
+            url.password ||
+            url.search ||
+            url.hash ||
+            match?.[1] === undefined)
+            throw new Error("Invalid reference");
+        return { requestId: match[1], requestRef: url.href };
+    },
+    catch: () => invalidResume("The authorization request URL must identify a publish request on the selected Registry."),
+});
+const pendingHuman = (pending, timedOut = false) => new PublishAuthorizationPending({
+    timedOut,
+    action: {
+        kind: "open-url",
+        purpose: "publish",
+        registryUrl: pending.registryUrl,
+        requestRef: pending.requestRef,
+        url: pending.authorizationUrl,
+        expiresAt: DateTime.formatIso(pending.expiresAt),
+        intervalSeconds: pending.interval,
+        resume: `Rerun the same publish command with unchanged inputs and --authorization-request ${pending.requestRef}. Add --wait-for-human SECONDS for a bounded wait.`,
+    },
+});
+export const runPollingPublishAuthorization = Effect.fn("Auth.runPollingPublishAuthorization")(function* (input) {
+    const auth = yield* AuthClient;
+    const store = yield* PendingPublishAuthorizationStore;
+    const expectedDigest = publicationSetDigest(input.publicationSet.candidates);
+    const pending = yield* Effect.gen(function* () {
+        if (input.authorizationRequest !== undefined) {
+            const reference = yield* readPublishAuthorizationReference(input.authorizationRequest, input.registryUrl);
+            const saved = yield* store.load(reference.requestRef);
+            if (Option.isNone(saved))
+                return yield* invalidResume("The private proof for this publish request is unavailable on this machine. A public URL alone cannot resume it.");
+            if (saved.value.registryUrl !== input.registryUrl ||
+                saved.value.requestId !== reference.requestId ||
+                saved.value.publicationSetDigest !== expectedDigest)
+                return yield* invalidResume("The publication set, archive bytes, visibility inputs or Registry changed. This request cannot authorize the changed material; review a new request.");
+            return saved.value;
+        }
+        const initiatorProof = makePkceVerifier();
+        const request = yield* auth.createPublishAuthorizationRequest({
+            registryUrl: input.registryUrl,
+            publicationSet: input.publicationSet,
+            delivery: {
+                kind: "polling",
+                proof_challenge: makePkceChallenge(initiatorProof),
+                proof_challenge_method: "S256",
+            },
+        });
+        const reference = yield* readPublishAuthorizationReference(`${input.registryUrl.replace(/\/+$/, "")}/v1/auth/publish-requests/${request.requestId}`, input.registryUrl);
+        const value = {
+            version: 1,
+            purpose: "publish",
+            registryUrl: input.registryUrl,
+            ...reference,
+            authorizationUrl: request.authorizationUrl,
+            expiresAt: request.expiresAt,
+            interval: request.interval,
+            publicationSetDigest: expectedDigest,
+            initiatorProof,
+        };
+        yield* store.save(value);
+        return value;
+    });
+    const expired = () => new RegistryAuthFailed({
+        category: "auth_expired",
+        detail: "This publish authorization expired. Review a new request; no capability was acquired.",
+        recover: "Rerun publish without --authorization-request to request new consent.",
+    });
+    const now = yield* DateTime.now;
+    const remaining = DateTime.toEpochMillis(pending.expiresAt) - DateTime.toEpochMillis(now);
+    if (remaining <= 0) {
+        yield* store.clear(pending.requestRef);
+        return yield* expired();
+    }
+    if (input.authorizationRequest === undefined &&
+        input.waitForHumanSeconds === undefined &&
+        input.unattended === true)
+        return yield* pendingHuman(pending);
+    if (input.authorizationRequest === undefined && input.unattended !== true) {
+        const interaction = yield* DeviceLoginInteraction;
+        const presenter = yield* AuthLoginPresenter;
+        const browserOpened = yield* interaction.openBrowser(pending.authorizationUrl);
+        yield* presenter.notePublishReview({
+            browserOpened,
+            candidateCount: input.publicationSet.candidates.length,
+            authorizationUrl: pending.authorizationUrl,
+        });
+    }
+    const wait = Effect.gen(function* () {
+        while (true) {
+            const status = yield* auth.pollPublishAuthorization({
+                registryUrl: pending.registryUrl,
+                requestId: pending.requestId,
+                initiatorProof: pending.initiatorProof,
+            });
+            if (status.purpose !== "publish" ||
+                status.publication_set_digest !== expectedDigest ||
+                DateTime.toEpochMillis(status.expires_at) !== DateTime.toEpochMillis(pending.expiresAt))
+                return yield* invalidResume("The Registry returned a different publication binding or deadline. This request cannot be resumed.");
+            if (status.status === "expired") {
+                yield* store.clear(pending.requestRef);
+                return yield* expired();
+            }
+            if (status.status === "denied") {
+                yield* store.clear(pending.requestRef);
+                return yield* new RegistryAuthFailed({
+                    category: "auth_denied",
+                    detail: "Publish authorization was cancelled. No publication was authorized.",
+                    recover: "Request new consent by rerunning publish without --authorization-request.",
+                });
+            }
+            if (status.status === "exchanged") {
+                yield* store.clear(pending.requestRef);
+                return yield* new RegistryAuthFailed({
+                    category: "conflict",
+                    detail: "This publish authorization was already exchanged. Verify the prior publication results before requesting new consent; the capabilities cannot be replayed.",
+                    recover: "Rerun publish with the original inputs to verify existing versions and request consent for any remaining material.",
+                });
+            }
+            if (status.status === "approved")
+                return;
+            if (input.unattended === true && input.waitForHumanSeconds === undefined)
+                return yield* pendingHuman(pending);
+            const current = yield* DateTime.now;
+            const left = DateTime.toEpochMillis(pending.expiresAt) - DateTime.toEpochMillis(current);
+            if (left <= 0)
+                return yield* expired();
+            yield* Effect.sleep(Math.min(status.interval * 1000, left));
+        }
+    });
+    const bound = Math.min(remaining, input.waitForHumanSeconds === undefined ? remaining : input.waitForHumanSeconds * 1000);
+    const result = yield* wait.pipe(Effect.timeoutOption(bound));
+    if (Option.isSome(result)) {
+        // A lost exchange response is not retried: a later resume observes the
+        // retained request and takes explicit publication-outcome recovery.
+        const exchange = yield* auth.exchangePublishAuthorization({
+            registryUrl: pending.registryUrl,
+            requestId: pending.requestId,
+            initiatorProof: pending.initiatorProof,
+        });
+        if (exchange.preview.publicationSetDigest !== expectedDigest ||
+            exchange.grants.some((grant) => grant.publishRequestId !== pending.requestId ||
+                grant.publicationSetDigest !== expectedDigest))
+            return yield* invalidResume("The exchanged capabilities do not match the reviewed publication set.");
+        return exchange;
+    }
+    const afterWait = yield* DateTime.now;
+    if (DateTime.toEpochMillis(pending.expiresAt) <= DateTime.toEpochMillis(afterWait)) {
+        yield* store.clear(pending.requestRef);
+        return yield* expired();
+    }
+    return yield* pendingHuman(pending, true);
+}, Effect.satisfiesSuccessType());
+//# sourceMappingURL=publish-authorization-polling.js.map

package/dist/src/publish-authorization.d.ts

@@ -6,6 +6,9 @@ import { AuthLoginPresenter } from "./login-presenter.js";
 export interface PublishAuthorizationInput {
     readonly registryUrl: string;
     readonly publicationSet: PreviewPublicationSetRequest;
+    readonly unattended?: boolean;
+    readonly authorizationRequest?: string;
+    readonly waitForHumanSeconds?: number;
 }
-export declare const runPublishAuthorization: (input: PublishAuthorizationInput) => Effect.Effect<PublishAuthorizationExchangeResponse, import("./errors.js").AuthError, AuthClient | AuthLoginPresenter | DeviceLoginInteraction>;
+export declare const runPublishAuthorization: (input: PublishAuthorizationInput) => Effect.Effect<PublishAuthorizationExchangeResponse, import("./errors.js").AuthError, AuthClient | AuthLoginPresenter | DeviceLoginInteraction | import("./pending-publish-authorization-store.ts").PendingPublishAuthorizationStore>;
 //# sourceMappingURL=publish-authorization.d.ts.map

package/dist/src/publish-authorization.js

@@ -1,3 +1,4 @@
+import { runPollingPublishAuthorization } from "./publish-authorization-polling.js";
 import * as Effect from "effect/Effect";
 import { RegistryAuthFailed } from "./errors.js";
 import { AuthClient } from "./auth-client.js";
@@ -35,6 +36,16 @@ const loopbackFailureToAuthFailure = (error) => {
     });
 };
 export const runPublishAuthorization = Effect.fn("Auth.runPublishAuthorization")(function* (input) {
+    if (input.waitForHumanSeconds !== undefined &&
+        (!Number.isSafeInteger(input.waitForHumanSeconds) || input.waitForHumanSeconds <= 0))
+        return yield* new RegistryAuthFailed({
+            category: "validation",
+            detail: "--wait-for-human must be a positive whole number of seconds.",
+        });
+    if (input.unattended === true ||
+        input.authorizationRequest !== undefined ||
+        input.waitForHumanSeconds !== undefined)
+        return yield* runPollingPublishAuthorization(input);
     return yield* Effect.scoped(Effect.gen(function* () {
         const authClient = yield* AuthClient;
         const presenter = yield* AuthLoginPresenter;
@@ -42,12 +53,16 @@ export const runPublishAuthorization = Effect.fn("Auth.runPublishAuthorization")
         const verifier = makePkceVerifier();
         const challenge = makePkceChallenge(verifier);
         const state = makeOAuthState();
-        const server = yield* startLoopbackServer(state).pipe(Effect.mapError(loopbackFailureToAuthFailure));
+        const server = yield* startLoopbackServer(state, "publish").pipe(Effect.mapError(loopbackFailureToAuthFailure));
         const request = yield* authClient.createPublishAuthorizationRequest({
             registryUrl: input.registryUrl,
-            redirectUri: server.redirectUri,
-            state,
-            codeChallenge: challenge,
+            delivery: {
+                kind: "loopback",
+                redirect_uri: server.redirectUri,
+                state,
+                code_challenge: challenge,
+                code_challenge_method: "S256",
+            },
             publicationSet: input.publicationSet,
         });
         const openedBrowser = yield* interaction.openBrowser(request.authorizationUrl);
@@ -57,7 +72,9 @@ export const runPublishAuthorization = Effect.fn("Auth.runPublishAuthorization")
             authorizationUrl: request.authorizationUrl,
         });
         const callback = yield* server
-            .awaitCallback(PUBLISH_AUTHORIZATION_TIMEOUT_MS)
+            .awaitCallback(Math.min(PUBLISH_AUTHORIZATION_TIMEOUT_MS, input.waitForHumanSeconds === undefined
+            ? PUBLISH_AUTHORIZATION_TIMEOUT_MS
+            : input.waitForHumanSeconds * 1000))
             .pipe(Effect.mapError(loopbackFailureToAuthFailure));
         const expectedIssuer = new URL(request.authorizationUrl).origin;
         if (callback.iss !== expectedIssuer) {
@@ -73,6 +90,8 @@ export const runPublishAuthorization = Effect.fn("Auth.runPublishAuthorization")
             verifier,
             redirectUri: server.redirectUri,
         });
+        if (capability.status === "admitted")
+            yield* server.complete;
         return capability;
     }));
 }, Effect.satisfiesSuccessType());

package/dist/src/testing.d.ts

@@ -11,4 +11,5 @@ export { DeviceLoginInteractionTest, type DeviceLoginInteractionTestState, } fro
 export { AuthLoginInteractionTest, type AuthLoginInteractionTestState, } from "./login-interaction.js";
 export { AuthLoginPresenterTest, type AuthLoginPresenterTestState } from "./login-presenter.js";
 export { PendingDeviceLoginStoreTest } from "./pending-device-login-store.js";
+export { PendingPublishAuthorizationStoreTest } from "./pending-publish-authorization-store.js";
 //# sourceMappingURL=testing.d.ts.map

package/dist/src/testing.js

@@ -11,4 +11,5 @@ export { DeviceLoginInteractionTest, } from "./device-login.js";
 export { AuthLoginInteractionTest, } from "./login-interaction.js";
 export { AuthLoginPresenterTest } from "./login-presenter.js";
 export { PendingDeviceLoginStoreTest } from "./pending-device-login-store.js";
+export { PendingPublishAuthorizationStoreTest } from "./pending-publish-authorization-store.js";
 //# sourceMappingURL=testing.js.map

package/package.json

@@ -4,9 +4,9 @@
     "url": "https://github.com/agentxm/axm/issues"
   },
   "dependencies": {
-    "@agentxm/extension-model": "^0.28.10",
-    "@agentxm/registry-client": "^0.28.10",
-    "@agentxm/registry-protocol": "^0.28.10",
+    "@agentxm/extension-model": "^0.28.12",
+    "@agentxm/registry-client": "^0.28.12",
+    "@agentxm/registry-protocol": "^0.28.12",
     "@napi-rs/keyring": "^1.3.0",
     "effect": "4.0.0-rc.112",
     "proper-lockfile": "^4.1.2"
@@ -61,5 +61,5 @@
   },
   "sideEffects": false,
   "type": "module",
-  "version": "0.28.10"
+  "version": "0.28.12"
 }