@awiki/dsh-plugin 0.3.5 → 0.3.7-dsh-test.20260831.1

package/lib/provider.js

@@ -1,26 +1,67 @@
-import { t as RustSdkAdapter } from "./sdk-adapter-CDLTgHJA.mjs";
+import { t as RustSdkAdapter } from "./sdk-adapter-FGaOi8It.mjs";
 import { openImCoreNodeClient } from "@awiki/im-core-node";
 //#region lib/types/provider.js
 /** Production AWiki provider backed by the versioned Rust IM Core Node bridge. */
 /** Cordis plugin name used by Loader diagnostics. */
 const name = "awiki-rust-sdk-provider";
-/** The AWiki service must own its provider registry before this plugin loads. */
-const inject = ["awiki"];
+/** AWiki orchestration and the independent identity service must load first. */
+const inject = ["awiki", "anpIdentity"];
+const IDENTITY_PROVIDER_CAPABILITIES = [
+	"IDENTITY_READ",
+	"IDENTITY_CREATE",
+	"IDENTITY_IMPORT",
+	"IDENTITY_SIGN",
+	"IDENTITY_ECDH_SEALED",
+	"IDENTITY_DOCUMENT_UPDATE",
+	"IDENTITY_KEY_LIFECYCLE",
+	"IDENTITY_DELETE",
+	"IDENTITY_HTTP_SIGNATURE",
+	"AWIKI_LEGACY_ROOT_TRANSFER_V1"
+];
 /** Register one SDK client whose disposal follows this provider's fiber. */
 function apply(ctx) {
-	ctx.effect(() => ctx.awiki.registerClientFactory((options) => new RustSdkAdapter(openImCoreNodeClient({
-		stateRoot: options.stateRoot,
-		serviceBaseUrl: options.userServiceUrl,
-		didDomain: options.userServiceDomain,
-		userServiceEndpoint: options.userServiceUrl,
-		messageServiceEndpoint: options.messageServiceUrl,
-		mailServiceEndpoint: options.mailServiceUrl,
-		anpServiceEndpoint: options.messageServiceUrl,
-		anpServiceDid: options.messageServiceDid,
-		multiDeviceHandleRecoveryEnabled: true,
-		multiDeviceAudience: "awiki-user-service",
-		externalHttpAllowInsecureLoopbackForTesting: options.allowInsecureLoopbackForTesting
-	}))), "awiki Rust SDK client");
+	ctx.effect(() => {
+		const lease = ctx.anpIdentity.acquireProvider({
+			consumer: "@awiki/dsh-plugin",
+			capabilities: [...IDENTITY_PROVIDER_CAPABILITIES],
+			ttlSeconds: 3600
+		});
+		try {
+			const unregister = ctx.awiki.registerClientFactory((options) => {
+				const openOptions = {
+					stateRoot: options.stateRoot,
+					serviceBaseUrl: options.userServiceUrl,
+					didDomain: options.userServiceDomain,
+					userServiceEndpoint: options.userServiceUrl,
+					messageServiceEndpoint: options.messageServiceUrl,
+					mailServiceEndpoint: options.mailServiceUrl,
+					anpServiceEndpoint: options.messageServiceUrl,
+					anpServiceDid: options.messageServiceDid,
+					clientVersionInfo: {
+						product: "awiki-daemon",
+						release: "0815",
+						version: "0.1.91"
+					},
+					multiDeviceHandleRecoveryEnabled: true,
+					multiDeviceDeviceRevokeEnabled: true,
+					multiDeviceAudience: "awiki-user-service",
+					externalHttpAllowInsecureLoopbackForTesting: options.allowInsecureLoopbackForTesting,
+					identityProvider: lease
+				};
+				return new RustSdkAdapter(openImCoreNodeClient(openOptions));
+			});
+			return async () => {
+				try {
+					await unregister();
+				} finally {
+					lease.dispose();
+				}
+			};
+		} catch (error) {
+			lease.dispose();
+			throw error;
+		}
+	}, "awiki Rust SDK client");
 }
 //#endregion
 export { apply, inject, name };

package/lib/{sdk-adapter-CDLTgHJA.mjs → sdk-adapter-FGaOi8It.mjs}

@@ -20,11 +20,12 @@ const RUST_FAILURE_CODES = {
 	auth_revoked: "identity-recovery-required",
 	conflict: "conflict",
 	join_required: "handle-unavailable",
-	state_in_use: "state-in-use",
+	state_in_use: "conflict",
 	rate_limited: "rate-limited",
 	timeout: "network",
 	transport_unavailable: "network",
 	sync_failed: "network",
+	sync_blocked: "conflict",
 	session_expired: "network",
 	attachment_transfer_network: "network",
 	recovery_reconciliation_unavailable: "network",
@@ -33,15 +34,36 @@ const RUST_FAILURE_CODES = {
 /** Closed provider error consumed by the Host's fixed public failure mapping. */
 var AwikiSdkError = class extends Error {
 	code;
+	realtimeFailureCode;
 	name = "AwikiSdkError";
-	constructor(code) {
+	constructor(code, realtimeFailureCode) {
 		super(`AWiki SDK operation failed: ${code}`);
 		this.code = code;
+		this.realtimeFailureCode = realtimeFailureCode;
 	}
 };
 function fail(code = "remote") {
 	throw new AwikiSdkError(code);
 }
+const REALTIME_RETRY_WARNING_PRIORITY = [
+	"sync.retry.local_state.actor_closed",
+	"sync.retry.local_state.database_busy",
+	"sync.retry.local_state.constraint_failed",
+	"sync.retry.local_state.schema_unavailable",
+	"sync.retry.local_state.storage_unavailable",
+	"sync.retry.local_state.codec_unavailable",
+	"sync.retry.local_state.other",
+	"sync.retry.transport_unavailable",
+	"sync.retry.service_unavailable",
+	"sync.retry.local_state_unavailable"
+];
+function realtimeSyncFailureCode(status, warnings) {
+	if (status === "retryable_failure") return REALTIME_RETRY_WARNING_PRIORITY.find((code) => warnings.includes(code)) ?? "sync.retryable_failure";
+	if (status === "recovery_required") return "sync.recovery_required";
+	if (status === "auth_revoked") return "sync.auth_revoked";
+	if (status === "blocked") return "sync.blocked";
+	return "sync.unexpected_status";
+}
 function mapError(error, ambiguousSend = false) {
 	if (error instanceof AwikiSdkError) throw error;
 	let code = "remote";
@@ -103,11 +125,6 @@ function uint32(value) {
 	if (!Number.isSafeInteger(value) || value < 0 || value > 4294967295) fail();
 	return value;
 }
-function recoveryE2eeGroupCount(impact) {
-	if (typeof impact !== "object" || impact === null) fail();
-	const value = impact;
-	return uint32(value.unsupportedE2eeGroupCount !== void 0 ? value.unsupportedE2eeGroupCount : value.unsupportedE2EeGroupCount);
-}
 function boolean(value) {
 	if (typeof value !== "boolean") fail();
 	return value;
@@ -197,6 +214,26 @@ function identity(value) {
 		registeredAt: safeInteger(value.registeredAtMs)
 	};
 }
+function joinProgress(value) {
+	return {
+		joinSessionId: required(value.joinSessionId),
+		localPhase: value.localPhase,
+		remoteState: value.remoteState,
+		expiresAt: required(value.expiresAt),
+		...value.sas === void 0 ? {} : { sas: required(value.sas) },
+		completed: boolean(value.completed),
+		...value.identity === void 0 ? {} : { identity: identity(value.identity) }
+	};
+}
+function adminJoinProgress(value) {
+	return {
+		joinSessionId: required(value.joinSessionId),
+		localPhase: value.localPhase,
+		remoteState: value.remoteState,
+		expiresAt: required(value.expiresAt),
+		...value.sas === void 0 ? {} : { sas: required(value.sas) }
+	};
+}
 function profile(value) {
 	return {
 		did: required(value.did),
@@ -307,17 +344,25 @@ var RustSdkAdapter = class {
 	client;
 	attachmentConversations = /* @__PURE__ */ new Map();
 	disposal;
+	realtime;
+	agentInbox;
 	listener;
 	constructor(client) {
 		this.client = Promise.resolve(client);
-		this.listener = {
+		this.realtime = {
 			syncNow: (reason) => this.listenerSyncNow(reason),
-			startRealtime: () => this.listenerStartRealtime(),
+			startRealtime: () => this.listenerStartRealtime()
+		};
+		this.agentInbox = {
 			listConversations: (request) => this.listenerConversations(request),
 			getHistory: (request) => this.listenerHistory(request),
 			markConversationRead: (conversationId) => this.markConversationRead(conversationId),
 			sendText: (request) => this.sendText(request)
 		};
+		this.listener = {
+			...this.realtime,
+			...this.agentInbox
+		};
 	}
 	async run(operation, ambiguousSend = false) {
 		try {
@@ -520,8 +565,7 @@ var RustSdkAdapter = class {
 		return this.run(async (client) => {
 			const result = await client.syncNow({ reason });
 			if (result.status === "idle" || result.status === "changed") return;
-			if (result.status === "auth_revoked") fail("identity-recovery-required");
-			fail("network");
+			throw new AwikiSdkError(result.status === "auth_revoked" ? "identity-recovery-required" : "network", realtimeSyncFailureCode(result.status, result.warnings));
 		});
 	}
 	listenerStartRealtime() {
@@ -529,6 +573,9 @@ var RustSdkAdapter = class {
 			const session = await client.startRealtime();
 			return {
 				nextEvent: () => this.run(() => session.nextEvent()),
+				getStatus: () => this.run(async () => {
+					return { connected: (await session.getStatus()).connected };
+				}),
 				stop: () => this.run(() => session.stop())
 			};
 		});
@@ -591,7 +638,114 @@ var RustSdkAdapter = class {
 		});
 	}
 	registerIdentity(request) {
-		return this.run(async (client) => identity(await client.completeRegistration(request)));
+		return this.run(async (client) => {
+			const value = await client.completeRegistrationWithOutcome(request);
+			if (value.status === "registered") return {
+				status: "registered",
+				identity: identity(value.identity)
+			};
+			return {
+				status: "join-required",
+				continuationId: required(value.existingHandle.continuationId),
+				fullHandle: required(value.existingHandle.fullHandle),
+				mode: value.existingHandle.mode === "handle_recovery_rebind" ? "handle-recovery-rebind" : "ordinary",
+				requiresUserPresence: boolean(value.existingHandle.requiresUserPresence)
+			};
+		});
+	}
+	beginDeviceJoin(request) {
+		return this.run(async (client) => joinProgress(await client.beginPreparedRegistrationJoin(request)));
+	}
+	getDeviceJoinStatus(joinSessionId) {
+		return this.run(async (client) => joinProgress(await client.resumePreparedRegistrationJoin({ joinSessionId })));
+	}
+	listLocalDeviceJoinSessions() {
+		return this.run(async (client) => (await client.listLocalDeviceJoinSessions()).map((value) => ({
+			joinSessionId: required(value.joinSessionId),
+			side: value.side,
+			localPhase: value.localPhase,
+			expiresAt: required(value.expiresAt)
+		})));
+	}
+	cancelDeviceJoin(joinSessionId) {
+		return this.run(async (client) => {
+			const value = await client.cancelPreparedRegistrationJoin({ joinSessionId });
+			return {
+				joinSessionId: required(value.joinSessionId),
+				side: value.side,
+				localPhase: value.localPhase,
+				expiresAt: required(value.expiresAt)
+			};
+		});
+	}
+	getCurrentDeviceSummary() {
+		return this.run(async (client) => {
+			const value = await client.getCurrentDeviceSummary();
+			return {
+				...value.role === void 0 ? {} : { role: value.role },
+				readiness: value.readiness,
+				canManage: boolean(value.canManage)
+			};
+		});
+	}
+	syncDeviceManagement() {
+		return this.run(async (client) => {
+			await client.syncNow({ reason: "foreground_reconcile" });
+		});
+	}
+	getDeviceRegistry() {
+		return this.run(async (client) => (await client.getDeviceRegistry()).devices.map((value) => ({
+			deviceId: required(value.protocolDeviceId),
+			status: value.status,
+			role: value.role,
+			managementReady: boolean(value.managementReady),
+			isCurrent: boolean(value.isCurrent)
+		})));
+	}
+	listLocalDeviceJoinRequests() {
+		return this.run(async (client) => (await client.listLocalDeviceJoinRequests()).map((value) => ({
+			joinSessionId: required(value.joinSessionId),
+			candidateKeyFingerprint: required(value.candidateKeyFingerprint),
+			issuedAt: required(value.issuedAt),
+			expiresAt: required(value.expiresAt),
+			state: value.state,
+			claimedByCurrentDevice: boolean(value.claimedByCurrentDevice),
+			canStartVerification: boolean(value.canStartVerification)
+		})));
+	}
+	startDeviceJoinVerification(request) {
+		return this.run(async (client) => adminJoinProgress(await client.startDeviceJoinVerification(request)));
+	}
+	getLocalDeviceJoinVerificationProgress(joinSessionId) {
+		return this.run(async (client) => adminJoinProgress(await client.getLocalDeviceJoinVerificationProgress({ joinSessionId })));
+	}
+	prepareDeviceJoinApproval(joinSessionId) {
+		return this.run(async (client) => {
+			return { approvalHandle: required((await client.prepareDeviceJoinApproval({
+				joinSessionId,
+				sasConfirmed: true
+			})).approvalHandle) };
+		});
+	}
+	confirmDeviceJoinApproval(approvalHandle) {
+		return this.run(async (client) => adminJoinProgress(await client.confirmDeviceJoinApproval({
+			approvalHandle,
+			userPresenceConfirmed: true
+		})));
+	}
+	rejectDeviceJoin(joinSessionId, reason) {
+		return this.run(async (client) => adminJoinProgress(await client.rejectDeviceJoin({
+			joinSessionId,
+			reason
+		})));
+	}
+	revokeDevice(deviceId) {
+		return this.run(async (client) => {
+			await client.revokeDevice({
+				targetDeviceId: deviceId,
+				userPresenceConfirmed: true
+			});
+		});
 	}
 	updateDisplayName(request) {
 		return this.run(async (client) => identity(await client.updateDisplayName(request.displayName)));
@@ -616,9 +770,7 @@ var RustSdkAdapter = class {
 			...value.failureCode === void 0 ? {} : { failureCode: value.failureCode },
 			retryable: boolean(value.retryable),
 			localOrdinaryDataWillMigrate: boolean(value.impact.localOrdinaryDataWillMigrate),
-			otherDevicesMustRejoin: boolean(value.impact.otherDevicesMustRejoin),
-			unsupportedE2eeGroupCount: recoveryE2eeGroupCount(value.impact),
-			unsupportedDidOnlyGroupCount: uint32(value.impact.unsupportedDidOnlyGroupCount)
+			otherDevicesMustRejoin: boolean(value.impact.otherDevicesMustRejoin)
 		};
 	}
 	sendRecoveryOtp(request) {
@@ -720,41 +872,6 @@ var RustSdkAdapter = class {
 			member
 		})));
 	}
-	resumeGroupRebindRecovery() {
-		return this.run(async (client) => {
-			const value = await client.resumeGroupRebindRecovery(100);
-			const journal = value;
-			const statuses = /* @__PURE__ */ new Map();
-			for (const item of journal.items ?? []) {
-				const { groupDid: rawGroupDid, layer: rawLayer, phase: rawPhase } = item;
-				if (typeof rawGroupDid !== "string" || typeof rawLayer !== "string" || typeof rawPhase !== "string" || typeof item.blocked !== "boolean") throw new TypeError("invalid group recovery item");
-				const groupDid = required(rawGroupDid);
-				const layer = required(rawLayer);
-				const phase = required(rawPhase);
-				if (layer !== "p4" && layer !== "p6") throw new TypeError("invalid group recovery item");
-				if (phase === "complete") continue;
-				const status = item.blocked || phase === "blocked" ? "blocked" : "pending";
-				if (statuses.get(groupDid) !== "blocked") statuses.set(groupDid, status);
-			}
-			for (const group of journal.sendPausedGroups ?? []) {
-				if (typeof group !== "string") throw new TypeError("invalid paused recovery group");
-				const groupDid = required(group);
-				if (!statuses.has(groupDid)) statuses.set(groupDid, "pending");
-			}
-			const items = [...statuses].map(([groupDid, status]) => ({
-				groupDid,
-				status
-			}));
-			const hasJournal = journal.items !== void 0 || journal.sendPausedGroups !== void 0;
-			return {
-				processed: uint32(value.processed),
-				completed: uint32(value.completed),
-				pending: hasJournal ? items.filter((item) => item.status === "pending").length : uint32(value.pending),
-				blocked: hasJournal ? items.filter((item) => item.status === "blocked").length : uint32(value.blocked),
-				items
-			};
-		});
-	}
 	listConversations(request) {
 		return this.run(async (client) => {
 			const conversations = await client.listConversations(request);