dsh-antigravity-auth 0.1.0

package/lib/index.js

@@ -0,0 +1,176 @@
+import { _ as defaultAuthStorePath, a as maskEmail, c as defaultCapabilityGatePath, d as ANTIGRAVITY_TOKEN_ENDPOINT, f as CredentialOperationError, g as credentialErrorMessage, h as createGoogleRevokeTransport, i as createAntigravityAuthService, l as OAuthFlowError, m as createGoogleRefreshTransport, o as createFileCapabilityGates, p as createCredentialCoordinator, r as AntigravityAuthService, s as createMemoryCapabilityGates, t as mountCapabilityLifecycle, u as ANTIGRAVITY_REVOKE_ENDPOINT } from "./capability-lifecycle--tgGKajs.js";
+import { a as DEFAULT_PRIVATE_RESPONSE_HEADER_TIMEOUT_MS, c as assertPrivateEndpoint, d as privateStatusError, f as readPrivateBytes, i as DEFAULT_PRIVATE_RESPONSE_BYTES, l as createPrivateTransport, m as PrivateTransportError, n as DEFAULT_PRIVATE_IDLE_TIMEOUT_MS, o as DEFAULT_PRIVATE_TOTAL_TIMEOUT_MS, p as readPrivateText, r as DEFAULT_PRIVATE_REQUEST_BYTES, s as MAX_PRIVATE_REQUEST_BYTES, t as DEFAULT_PRIVATE_FRAME_BYTES, u as iteratePrivateSse } from "./private-transport-urF138qW.js";
+import { AGY_PROVIDER_USER_AGENT, ANTIGRAVITY_WIRE_ORIGIN, ANTIGRAVITY_WIRE_ORIGINS, ANTIGRAVITY_WIRE_PATHS, DSH_ATTRIBUTION_HEADER, WireIdentityError, assertWireIdentityInvariant, buildWireIdentityHeaders, createWireIdentity } from "./wire-identity.js";
+import { PROJECT_DISCOVERY_ENDPOINT, PROJECT_DISCOVERY_PATH, ProjectDiscoveryError, createProjectContext, createProjectDiscovery, normalizeProjectId } from "./project-context.js";
+import { a as createStatusView, i as LLM_FAMILY_IDS, n as CAPABILITY_GATE_OUTCOMES, r as CAPABILITY_ROW_IDS, t as ANTIGRAVITY_PLUGIN_ID } from "./status-D0-em3Ru.js";
+import { ANTIGRAVITY_QUOTA_ENDPOINT, QUOTA_REFRESH_MIN_INTERVAL_MS, QuotaNormalizationError, createQuotaService, normalizeQuotaResponse } from "./quota.js";
+import { ANTIGRAVITY_REPLAY_VERSION, antigravityModelFamily, buildFunctionDeclarations, compatibleReplayState, createReplayState, sanitizeToolSchemas } from "./replay.js";
+import { ANTIGRAVITY_AVAILABLE_MODELS_ENDPOINT, ANTIGRAVITY_GENERATE_ENDPOINT, ANTIGRAVITY_LLM_ROUTE, ANTIGRAVITY_PROVIDER, ANTIGRAVITY_STREAM_ENDPOINT, AntigravityAdapter, buildAntigravityGeneratePayload } from "./llm-adapter.js";
+import { a as parseUsageResult, c as safeRpcErrorMessage, i as parseStatusResult, n as createAntigravityAuthRpcClient, o as ANTIGRAVITY_MODEL_CATALOG_STATES, r as parseModelCatalogResult, s as isSafeRpcErrorCode, t as ANTIGRAVITY_AUTH_RPC_CHANNEL } from "./rpc-contract-BFWfdKKs.js";
+import { DEFAULT_INLINE_IMAGE_BYTES, DEFAULT_VIDEO_BYTES, IMAGE_HANDLE_PATTERN, MediaAdmissionError, admitBase64Image, admitImageBytes, admitSessionImage, admitWorkspaceImage, admitWorkspaceVideo, detectImageMediaType, imageHandle, isMp4, sessionImageCatalog } from "./media-admission.js";
+import { LIVE_ACKNOWLEDGEMENT, LIVE_GATE_IDS, runLiveGateCli } from "./live-gates.js";
+//#region src/rpc.ts
+/** Dispatch closed, value-safe requests; callback URLs are never echoed. */
+async function handleAntigravityAuthRpc(service, endpoint, payload, signal, modelCatalog) {
+	if (signal?.aborted === true) return cancelled();
+	try {
+		if (endpoint === "status") {
+			if (!isEmptyRecord(payload)) return badRequest("status expects an empty payload");
+			return {
+				ok: true,
+				value: { status: await service.status() }
+			};
+		}
+		if (endpoint === "models") {
+			if (!isRefreshPayload(payload)) return badRequest("models expects {} or { force: boolean }");
+			if (modelCatalog === void 0) return badRequest("model catalog is unavailable");
+			const status = await service.status();
+			return {
+				ok: true,
+				value: status.login.projectAvailable && status.capabilities.some((capability) => capability.id === "auth-llm" && capability.state === "available") ? await modelCatalog.modelCatalog(signal, payload.force) : modelCatalog.catalogSnapshot()
+			};
+		}
+		if (endpoint === "usage") {
+			if (!isRefreshPayload(payload)) return badRequest("usage expects {} or { force: boolean }");
+			if (service.usage === void 0) return {
+				ok: true,
+				value: { state: "protocol-drift" }
+			};
+			return {
+				ok: true,
+				value: await service.usage(signal, payload.force)
+			};
+		}
+		if (endpoint === "acknowledge-risk") {
+			if (!isAcknowledgement(payload)) return badRequest("acknowledge-risk expects { acknowledge: true }");
+			return {
+				ok: true,
+				value: await service.acknowledgeRisk()
+			};
+		}
+		if (endpoint === "login") {
+			if (!isEmptyRecord(payload)) return badRequest("login expects an empty payload");
+			return {
+				ok: true,
+				value: await service.startLogin()
+			};
+		}
+		if (endpoint === "cancel" || endpoint === "cancel-login") {
+			if (!isEmptyRecord(payload)) return badRequest("cancel expects an empty payload");
+			return {
+				ok: true,
+				value: await service.cancelLogin()
+			};
+		}
+		if (endpoint === "logout") {
+			if (!isEmptyRecord(payload)) return badRequest("logout expects an empty payload");
+			return {
+				ok: true,
+				value: await service.logout()
+			};
+		}
+		if (endpoint === "revoke") {
+			if (!isRevokePayload(payload)) return badRequest("revoke expects { confirmed: true }");
+			return {
+				ok: true,
+				value: await service.revoke(true, signal)
+			};
+		}
+		return badRequest("unknown Antigravity auth endpoint");
+	} catch (error) {
+		return safeFailure(error);
+	}
+}
+function badRequest(message) {
+	return {
+		ok: false,
+		error: {
+			code: "bad-request",
+			message,
+			details: { issues: [] }
+		}
+	};
+}
+function cancelled() {
+	return {
+		ok: false,
+		error: {
+			code: "cancelled",
+			message: "antigravity-auth: request cancelled",
+			details: {}
+		}
+	};
+}
+function safeFailure(error) {
+	const credentialError = error instanceof CredentialOperationError ? error : void 0;
+	const candidate = error instanceof OAuthFlowError ? error.code : credentialError?.code ?? "internal";
+	const code = isSafeRpcErrorCode(candidate) ? candidate : "internal";
+	return {
+		ok: false,
+		error: {
+			code,
+			message: credentialError === void 0 ? safeRpcErrorMessage(code) : credentialErrorMessage(credentialError.code) ?? safeRpcErrorMessage(code),
+			details: {}
+		}
+	};
+}
+function isEmptyRecord(value) {
+	return isRecord(value) && Object.keys(value).length === 0;
+}
+function isRefreshPayload(value) {
+	return isRecord(value) && Object.keys(value).every((key) => key === "force") && (value.force === void 0 || typeof value.force === "boolean");
+}
+function isAcknowledgement(value) {
+	return isRecord(value) && Object.keys(value).length === 1 && value.acknowledge === true;
+}
+function isRevokePayload(value) {
+	return isRecord(value) && Object.keys(value).length === 1 && value.confirmed === true;
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+//#endregion
+//#region src/index.ts
+const name = "antigravity-auth";
+const inject = [
+	"connection",
+	"llm",
+	"attachments"
+];
+/** Mount the Host-only OAuth service and its loopback RPC channel. */
+function apply(ctx) {
+	const service = createAntigravityAuthService({
+		storePath: defaultAuthStorePath(),
+		autoActivateGates: true
+	});
+	const runtime = ctx;
+	const adapter = new AntigravityAdapter({
+		auth: service,
+		...runtime.attachments === void 0 ? {} : { attachments: runtime.attachments }
+	});
+	const unprovide = ctx.provide?.("antigravityAuth", service) ?? (() => {});
+	ctx.inject(["connection"], (connectionCtx) => connectionCtx.connection.rpc.handle(ANTIGRAVITY_AUTH_RPC_CHANNEL, (endpoint, payload, signal) => handleAntigravityAuthRpc(service, endpoint, payload, signal, adapter), { authority: "loopback" }));
+	mountCapabilityLifecycle({
+		ctx,
+		auth: service,
+		id: "auth-llm",
+		enabled: () => runtime.llm?.registerAdapter !== void 0,
+		register: () => {
+			if (runtime.llm?.registerAdapter === void 0) return void 0;
+			if (runtime.llm.listProviders?.().some((provider) => provider.id === "google-antigravity")) return void 0;
+			const dispose = runtime.llm.registerAdapter([ANTIGRAVITY_PROVIDER], adapter);
+			return () => {
+				try {
+					dispose();
+				} finally {
+					adapter.invalidateModelCatalog();
+				}
+			};
+		},
+		ownsAuth: true,
+		cleanup: unprovide,
+		label: "antigravity-auth: OAuth and LLM operations"
+	});
+}
+//#endregion
+export { AGY_PROVIDER_USER_AGENT, ANTIGRAVITY_AUTH_RPC_CHANNEL, ANTIGRAVITY_AVAILABLE_MODELS_ENDPOINT, ANTIGRAVITY_GENERATE_ENDPOINT, ANTIGRAVITY_LLM_ROUTE, ANTIGRAVITY_MODEL_CATALOG_STATES, ANTIGRAVITY_PLUGIN_ID, ANTIGRAVITY_PROVIDER, ANTIGRAVITY_QUOTA_ENDPOINT, ANTIGRAVITY_REPLAY_VERSION, ANTIGRAVITY_REVOKE_ENDPOINT, ANTIGRAVITY_STREAM_ENDPOINT, ANTIGRAVITY_TOKEN_ENDPOINT, ANTIGRAVITY_WIRE_ORIGIN, ANTIGRAVITY_WIRE_ORIGINS, ANTIGRAVITY_WIRE_PATHS, AntigravityAdapter, AntigravityAuthService, CAPABILITY_GATE_OUTCOMES, CAPABILITY_ROW_IDS, CredentialOperationError, DEFAULT_INLINE_IMAGE_BYTES, DEFAULT_PRIVATE_FRAME_BYTES, DEFAULT_PRIVATE_IDLE_TIMEOUT_MS, DEFAULT_PRIVATE_REQUEST_BYTES, DEFAULT_PRIVATE_RESPONSE_BYTES, DEFAULT_PRIVATE_RESPONSE_HEADER_TIMEOUT_MS, DEFAULT_PRIVATE_TOTAL_TIMEOUT_MS, DEFAULT_VIDEO_BYTES, DSH_ATTRIBUTION_HEADER, IMAGE_HANDLE_PATTERN, LIVE_ACKNOWLEDGEMENT, LIVE_GATE_IDS, LLM_FAMILY_IDS, MAX_PRIVATE_REQUEST_BYTES, MediaAdmissionError, PROJECT_DISCOVERY_ENDPOINT, PROJECT_DISCOVERY_PATH, PrivateTransportError, ProjectDiscoveryError, QUOTA_REFRESH_MIN_INTERVAL_MS, QuotaNormalizationError, WireIdentityError, admitBase64Image, admitImageBytes, admitSessionImage, admitWorkspaceImage, admitWorkspaceVideo, antigravityModelFamily, apply, assertPrivateEndpoint, assertWireIdentityInvariant, buildAntigravityGeneratePayload, buildFunctionDeclarations, buildWireIdentityHeaders, compatibleReplayState, createAntigravityAuthRpcClient, createAntigravityAuthService, createCredentialCoordinator, createFileCapabilityGates, createGoogleRefreshTransport, createGoogleRevokeTransport, createMemoryCapabilityGates, createPrivateTransport, createProjectContext, createProjectDiscovery, createQuotaService, createReplayState, createStatusView, createWireIdentity, credentialErrorMessage, defaultCapabilityGatePath, detectImageMediaType, imageHandle, inject, isMp4, iteratePrivateSse, maskEmail, name, normalizeProjectId, normalizeQuotaResponse, parseModelCatalogResult, parseStatusResult, parseUsageResult, privateStatusError, readPrivateBytes, readPrivateText, runLiveGateCli, sanitizeToolSchemas, sessionImageCatalog };

package/lib/invariant.js

@@ -0,0 +1,2 @@
+import { assertWireIdentityInvariant } from "./wire-identity.js";
+export { assertWireIdentityInvariant };