@ftai/dsh-plugin-acn 0.0.0-stage → 0.1.0

package/lib/effects-DJ4Xa7Tx.js

@@ -0,0 +1,268 @@
+import { d as InboxIdSchema, f as PolicyIdSchema, m as SourceIdSchema, t as ClaimSchema, v as deriveTraceId, x as nowSeconds } from "./claim-DOAGe8ZK.js";
+import { C as StoreError, c as readYamlOr, l as writeYamlAtomic, n as withFileLock, s as readYaml, w as hasCode } from "./lock-DbmlKOoX.js";
+import { a as analysisIsStale, c as observeApplied, i as STALE_PLAN_WARNING, l as sameClaim, o as claimChanges, s as ensureKnowledgeReady, t as AnalysisChanged } from "./alignment-CwH0nBf-.js";
+import { i as ClaimStore } from "./reported-sets-DdEKdeVb.js";
+import { t as TraceSchema } from "./trace-Da0RnL5R.js";
+import { t as TraceStore } from "./traces-CHBo8y1z.js";
+import { t as DisputeSchema } from "./dispute-CtrInHzf.js";
+import { r as UploadStore } from "./uploads-BCA2p92b.js";
+import { t as DreamStore } from "./checkpoint-RgcdqifN.js";
+import { i as inboxEventAt, n as InboxMessageSchema } from "./inbox-DFtE2fOp.js";
+import { n as ClaimEditStore, t as DisputeStore } from "./disputes-ByEmi43j.js";
+import { t as InboxStore } from "./inbox-2CugZZQm.js";
+import { n as FormationStore, r as newDisputes } from "./checkpoint-Bmt8q2vB.js";
+import { z } from "zod";
+import { createHash } from "node:crypto";
+import fs from "node:fs/promises";
+import { join } from "node:path";
+//#region src/inbox/effects.ts
+const HashSchema = z.string().regex(/^[0-9a-f]{64}$/);
+const MemberSchema = z.strictObject({
+	id: InboxIdSchema,
+	hash: HashSchema,
+	message: InboxMessageSchema
+});
+const InboxEffectSchema = z.strictObject({
+	schemaVersion: z.literal(1),
+	type: z.literal("effect"),
+	canonicalId: InboxIdSchema,
+	batchHash: HashSchema,
+	members: z.array(MemberSchema).min(1),
+	status: z.enum(["prepared", "applied"]),
+	analysisClaims: z.array(ClaimSchema).nullable(),
+	preparedClaims: z.array(ClaimSchema),
+	appliedClaims: z.array(ClaimSchema),
+	teamAuthorized: z.boolean().optional(),
+	syncClaims: z.array(ClaimSchema).optional(),
+	disputes: z.array(DisputeSchema),
+	trace: TraceSchema.nullable(),
+	warnings: z.array(z.string()),
+	retiredPolicies: z.array(PolicyIdSchema)
+});
+const RefSchema = z.strictObject({
+	schemaVersion: z.literal(1),
+	type: z.literal("ref"),
+	id: InboxIdSchema,
+	canonicalId: InboxIdSchema,
+	batchHash: HashSchema,
+	messageHash: HashSchema
+});
+const JournalSchema = z.discriminatedUnion("type", [InboxEffectSchema, RefSchema]);
+function canonicalJson(value) {
+	return JSON.stringify(value, (_key, item) => typeof item === "object" && item !== null && !Array.isArray(item) ? Object.fromEntries(Object.entries(item).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0)) : item);
+}
+const hash = (value) => createHash("sha256").update(canonicalJson(value)).digest("hex");
+const inboxMessageHash = (message) => hash(JSON.parse(JSON.stringify({
+	...message,
+	handled_at: void 0
+})));
+const batchHash = (members) => hash(members.map(({ id, hash }) => ({
+	id,
+	hash
+})));
+function integrity(condition) {
+	if (!condition) throw new StoreError("conflict", "Inbox effect journal integrity check failed.");
+}
+var InboxEffectStore = class {
+	context;
+	constructor(context) {
+		this.context = context;
+	}
+	async journals() {
+		let names;
+		try {
+			names = (await fs.readdir(join(this.context.paths.inbox, "effects"))).filter((name) => name.endsWith(".yaml") && !name.includes(".tmp."));
+		} catch (error) {
+			if (hasCode(error, "ENOENT")) return /* @__PURE__ */ new Map();
+			throw error;
+		}
+		const entries = await Promise.all(names.sort().map(async (name) => {
+			const journal = await readYaml(join(this.context.paths.inbox, "effects", name), JournalSchema);
+			integrity(name === `${journal.type === "effect" ? journal.canonicalId : journal.id}.yaml`);
+			return [name.slice(0, -5), journal];
+		}));
+		const result = new Map(entries);
+		for (const [id, journal] of result) if (journal.type === "ref") {
+			const canonical = result.get(journal.canonicalId);
+			integrity(canonical?.type === "effect" && canonical.canonicalId !== id);
+			const member = canonical.members.find((member) => member.id === id);
+			integrity(member !== void 0 && member.hash === journal.messageHash && canonical.batchHash === journal.batchHash);
+		} else {
+			integrity(journal.members[0]?.id === journal.canonicalId && new Set(journal.members.map((member) => member.id)).size === journal.members.length && batchHash(journal.members) === journal.batchHash);
+			integrity(journal.members.every((member) => member.id === member.message.id && member.hash === inboxMessageHash(member.message)));
+			integrity([...journal.preparedClaims, ...journal.appliedClaims].every((claim) => claim.holder === this.context.agentId));
+			integrity((journal.syncClaims ?? []).every((claim) => claim.holder === this.context.agentId && claim.status === "deprecated" && journal.retiredPolicies.some((id) => claim.source_claim_ids.includes(id))));
+			integrity(journal.trace === null || journal.trace.agent === this.context.agentId);
+			integrity(journal.disputes.every((dispute) => dispute.reporter_agent_id === this.context.agentId));
+			for (const member of journal.members.slice(1)) {
+				const ref = result.get(member.id);
+				integrity(ref === void 0 || ref.type === "ref" && ref.canonicalId === id && ref.batchHash === journal.batchHash && ref.messageHash === member.hash);
+			}
+		}
+		return result;
+	}
+	write(effect) {
+		return writeYamlAtomic(this.context.paths.inboxEffect(effect.canonicalId), effect, InboxEffectSchema, this.context.logger);
+	}
+	async references(effect) {
+		for (const member of effect.members.slice(1)) {
+			const ref = {
+				schemaVersion: 1,
+				type: "ref",
+				id: member.id,
+				canonicalId: effect.canonicalId,
+				batchHash: effect.batchHash,
+				messageHash: member.hash
+			};
+			const existing = await readYamlOr(this.context.paths.inboxEffect(member.id), JournalSchema, () => null);
+			if (existing === null) await writeYamlAtomic(this.context.paths.inboxEffect(member.id), ref, RefSchema, this.context.logger);
+			else integrity(canonicalJson(existing) === canonicalJson(ref));
+		}
+	}
+	async recover() {
+		if ((await this.journals()).size === 0) return;
+		await withFileLock(this.context.paths.knowledgeLock, () => this.recoverLocked(), { timeoutMs: this.context.lockTimeoutMs });
+	}
+	async recoverLocked() {
+		await new DreamStore(this.context).recoverLocked();
+		const effects = [...(await this.journals()).values()].filter((journal) => journal.type === "effect").sort((a, b) => (a.members[0] === void 0 ? "" : inboxEventAt(a.members[0].message)).localeCompare(b.members[0] === void 0 ? "" : inboxEventAt(b.members[0].message)));
+		for (const effect of effects) for (const member of effect.members) await new InboxStore(this.context).validateSnapshotLocked(member.message);
+		for (const effect of effects) {
+			await this.references(effect);
+			if (effect.status === "prepared") await this.applyLocked(effect);
+			else for (const member of effect.members) await new InboxStore(this.context).completeSnapshotLocked(member.message);
+		}
+	}
+	async commit(messages, analysisClaims, prepared, control) {
+		return withFileLock(this.context.paths.knowledgeLock, async () => {
+			await new DreamStore(this.context).recoverLocked();
+			await ensureKnowledgeReady(this.context.paths.root);
+			await new ClaimEditStore(this.context).recoverLocked();
+			await new FormationStore(this.context).recoverLocked();
+			await this.recoverLocked();
+			const first = messages[0];
+			integrity(first !== void 0);
+			for (const message of messages) await new InboxStore(this.context).validateSnapshotLocked(message);
+			const existing = await this.journals();
+			if (messages.some((message) => existing.has(message.id))) {
+				integrity(messages.every((message) => {
+					const journal = existing.get(message.id);
+					const canonical = journal?.type === "effect" ? journal : journal === void 0 ? void 0 : existing.get(journal.canonicalId);
+					return canonical?.type === "effect" && canonical.members.some((member) => member.id === message.id && member.hash === inboxMessageHash(message));
+				}));
+				return {
+					applied: 0,
+					warnings: []
+				};
+			}
+			if (claimChanges(analysisClaims, prepared.claims, [], await new ClaimStore(this.context).list()).length > 0) throw new AnalysisChanged();
+			const members = messages.map((message) => ({
+				id: message.id,
+				hash: inboxMessageHash(message),
+				message
+			}));
+			const traceInputs = [.../* @__PURE__ */ new Set([
+				...messages.map((message) => message.policy.id),
+				...messages.flatMap((message) => message.message_type === "claim_attribute_update" ? message.arbitration_resolution?.direct_claim_snapshots.map((claim) => claim.id) ?? [] : []),
+				...prepared.usedClaimIds,
+				...prepared.claims.flatMap((claim) => claim.source_claim_ids)
+			])].map((id) => SourceIdSchema.parse(id)).sort();
+			const createdAt = nowSeconds();
+			const name = first.message_type;
+			const traceIds = new Set((await new TraceStore(this.context).list()).map((trace) => trace.id));
+			let traceId = deriveTraceId(createdAt, name, traceInputs, prepared.claims.map((claim) => claim.id));
+			for (let attempt = 0; traceIds.has(traceId); attempt += 1) {
+				if (attempt >= 7) throw new StoreError("conflict", "Inbox Trace ID collision; retry the task.");
+				traceId = deriveTraceId(createdAt, name, traceInputs, prepared.claims.map((claim) => claim.id));
+			}
+			const trace = prepared.claims.length === 0 && prepared.disputes.length === 0 ? null : TraceSchema.parse({
+				id: traceId,
+				name,
+				task: `Inbox ${messages.map((message) => message.id).join(", ")}`,
+				agent: this.context.agentId,
+				input_claims: traceInputs,
+				output_claims: prepared.claims.map((claim) => claim.id),
+				created_at: createdAt
+			});
+			const existingDisputes = await new DisputeStore(this.context).list();
+			const disputes = await newDisputes(this.context, prepared.disputes, existingDisputes);
+			if (disputes.some((dispute) => existingDisputes.some((existing) => existing.id === dispute.id))) throw new StoreError("conflict", "Inbox Dispute ID collision; retry the task.");
+			const effect = InboxEffectSchema.parse({
+				schemaVersion: 1,
+				type: "effect",
+				canonicalId: first.id,
+				batchHash: batchHash(members),
+				members,
+				status: "prepared",
+				teamAuthorized: this.context.mode === "team",
+				syncClaims: prepared.syncClaims ?? [],
+				analysisClaims,
+				preparedClaims: prepared.claims,
+				appliedClaims: [],
+				disputes,
+				trace,
+				warnings: prepared.warnings,
+				retiredPolicies: messages.filter((message) => message.message_type === "policy_update" && message.policy.status === "deprecated").map((message) => message.policy.id)
+			});
+			control.signal.throwIfAborted();
+			control.prepared();
+			await this.write(effect);
+			await this.references(effect);
+			await this.applyLocked(effect);
+			return {
+				applied: effect.appliedClaims.length,
+				warnings: effect.warnings,
+				entityIds: [
+					...effect.appliedClaims.map((claim) => claim.id),
+					...effect.disputes.map((dispute) => dispute.id),
+					...effect.trace === null ? [] : [effect.trace.id]
+				]
+			};
+		}, {
+			timeoutMs: this.context.lockTimeoutMs,
+			signal: control.signal
+		});
+	}
+	async applyLocked(effect) {
+		await ensureKnowledgeReady(this.context.paths.root);
+		const current = await new ClaimStore(this.context).list();
+		observeApplied(effect.preparedClaims, current, effect.appliedClaims);
+		if (analysisIsStale(effect.analysisClaims, claimChanges(effect.analysisClaims, effect.preparedClaims, effect.appliedClaims, current))) {
+			effect.warnings.push(STALE_PLAN_WARNING);
+			this.context.logger.warn(STALE_PLAN_WARNING);
+			effect.preparedClaims = [];
+			effect.syncClaims = [];
+			effect.disputes = [];
+			effect.analysisClaims = current;
+			await this.write(effect);
+		}
+		for (const target of [...effect.preparedClaims].sort((a, b) => Number(a.status === "deprecated") - Number(b.status === "deprecated"))) {
+			if (effect.appliedClaims.some((claim) => claim.id === target.id)) continue;
+			await new ClaimStore(this.context).write(target);
+			effect.appliedClaims.push(target);
+			await this.write(effect);
+		}
+		if (effect.trace !== null) {
+			effect.trace.output_claims = effect.appliedClaims.map((claim) => claim.id);
+			await new TraceStore(this.context).write(effect.trace);
+		}
+		for (const dispute of effect.disputes) await new DisputeStore(this.context).write(dispute);
+		if (effect.teamAuthorized === void 0 && this.context.mode === "team") {
+			const warning = "旧 Inbox 事务缺少团队共享授权，仅恢复本地效果。";
+			effect.warnings.push(warning);
+			this.context.logger.warn(warning);
+		}
+		if (effect.teamAuthorized === true && this.context.mode === "team") {
+			const uploads = new UploadStore(this.context);
+			for (const policy of effect.retiredPolicies) await uploads.withdrawPolicy(policy);
+			const actual = await new ClaimStore(this.context).list();
+			const staged = [...new Map([...effect.appliedClaims, ...effect.syncClaims ?? []].map((claim) => [claim.id, claim])).values()];
+			await uploads.enqueue(staged.filter((claim) => actual.some((value) => sameClaim(value, claim))), effect.disputes, true);
+		}
+		effect.status = "applied";
+		await this.write(effect);
+		for (const member of effect.members) await new InboxStore(this.context).completeSnapshotLocked(member.message);
+	}
+};
+//#endregion
+export { InboxEffectStore as n, inboxMessageHash as r, InboxEffectSchema as t };

package/lib/errors-Bp_2WXBr.js

@@ -0,0 +1,19 @@
+//#region src/knowledge/errors.ts
+var KnowledgeError = class extends Error {
+	kind;
+	constructor(kind, message) {
+		super(message);
+		this.kind = kind;
+		this.name = "KnowledgeError";
+	}
+};
+var RevisionConflict = class extends KnowledgeError {
+	currentRevision;
+	constructor(currentRevision) {
+		super("conflict", `Claim revision conflict; current revision: ${currentRevision}`);
+		this.currentRevision = currentRevision;
+		this.name = "RevisionConflict";
+	}
+};
+//#endregion
+export { RevisionConflict as n, KnowledgeError as t };

package/lib/errors-pPumDOGD.js

@@ -0,0 +1,18 @@
+//#region src/team/errors.ts
+var TeamError = class extends Error {
+	kind;
+	service;
+	operation;
+	status;
+	connectionFailure;
+	constructor(kind, service, operation, status, connectionFailure) {
+		super(`${service} ${operation}：${kind === "auth" ? "鉴权失败，请在 ACN 设置检查 Agent ID 和团队鉴权密钥。" : kind === "legacy_route" ? "服务端不支持 Inbox receipt ACK，请联系团队管理员检查服务版本。" : kind === "retryable" ? "服务暂时不可用，本地知识和待投递任务已保留。" : kind === "protocol" ? "响应不符合团队协议，请检查服务版本。" : kind === "cancelled" ? "请求已取消。" : "请求被服务端拒绝，请检查请求权限与参数。"}${status === void 0 ? "" : ` status=${status}`}`);
+		this.kind = kind;
+		this.service = service;
+		this.operation = operation;
+		this.status = status;
+		this.connectionFailure = connectionFailure;
+	}
+};
+//#endregion
+export { TeamError as t };