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

package/lib/queue-M917xHPS.js

@@ -0,0 +1,153 @@
+import { C as StoreError, _ as JobError, c as readYamlOr, l as writeYamlAtomic, n as withFileLock, w as hasCode, x as jobPriority, y as JobSchema } from "./lock-DbmlKOoX.js";
+import { z } from "zod";
+import { randomUUID } from "node:crypto";
+import fs from "node:fs/promises";
+//#region src/worker/queue.ts
+function runnableJob(job, kinds, now = Date.now()) {
+	return job.state === "queued" && job.payload["paused"] !== true && kinds.has(job.kind) && (job.nextRunAt ?? 0) <= now;
+}
+var JobQueue = class {
+	context;
+	constructor(context) {
+		this.context = context;
+	}
+	async list() {
+		let entries;
+		try {
+			entries = await fs.readdir(this.context.paths.jobs, { withFileTypes: true });
+		} catch (error) {
+			if (hasCode(error, "ENOENT")) return [];
+			throw error;
+		}
+		return (await Promise.all(entries.filter((entry) => entry.isFile() && /^[a-zA-Z0-9_-]+\.yaml$/.test(entry.name)).map((entry) => this.read(entry.name.slice(0, -5))))).filter((value) => value !== null);
+	}
+	async read(id) {
+		const value = await readYamlOr(this.context.paths.job(id), z.preprocess((value) => typeof value === "object" && value !== null && "kind" in value && value.kind === "memory_review" ? null : value, JobSchema.nullable()), () => null);
+		if (value !== null && value.id !== id) throw new StoreError("decode", "Job ID differs from its filename.");
+		return value;
+	}
+	write(job) {
+		return writeYamlAtomic(this.context.paths.job(job.id), job, JobSchema, this.context.logger);
+	}
+	locked(action) {
+		return withFileLock(this.context.paths.jobQueueLock, action, { timeoutMs: this.context.lockTimeoutMs });
+	}
+	enqueue(kind, payload, sessionId) {
+		return this.locked(async () => {
+			const jobs = await this.list();
+			if (kind === "dream") {
+				const pending = jobs.find((job) => job.kind === kind && (job.state === "queued" || job.state === "running"));
+				if (pending !== void 0) return pending;
+			}
+			const same = jobs.find((job) => job.kind === kind && job.sessionId === sessionId && job.state === "queued" && JSON.stringify(job.payload) === JSON.stringify(payload));
+			if (same !== void 0) return same;
+			if (kind === "finalize") {
+				for (const job of jobs) if (job.kind === "recap" && job.sessionId === sessionId && job.state === "queued") await this.write({
+					...job,
+					state: "succeeded",
+					updatedAt: Date.now(),
+					result: { skipped: "superseded" }
+				});
+			}
+			const now = Date.now();
+			const job = JobSchema.parse({
+				schemaVersion: 1,
+				id: randomUUID(),
+				kind,
+				...sessionId === void 0 ? {} : { sessionId },
+				payload,
+				state: "queued",
+				attempts: 0,
+				createdAt: now,
+				updatedAt: now,
+				ordinal: Math.max(0, ...jobs.map((job) => job.ordinal ?? 0)) + 1
+			});
+			await this.write(job);
+			return job;
+		});
+	}
+	recoverRunning() {
+		return this.locked(async () => {
+			for (const job of await this.list()) if (job.state === "running") await this.write({
+				...job,
+				state: "queued",
+				updatedAt: Date.now()
+			});
+		});
+	}
+	claim(kinds) {
+		return this.locked(async () => {
+			const now = Date.now();
+			const jobs = (await this.list()).filter((job) => runnableJob(job, kinds, now));
+			jobs.sort((a, b) => jobPriority[a.kind] - jobPriority[b.kind] || (a.ordinal !== void 0 && b.ordinal !== void 0 ? a.ordinal - b.ordinal : a.createdAt - b.createdAt) || a.id.localeCompare(b.id));
+			const first = jobs[0];
+			if (first === void 0) return null;
+			const job = {
+				...first,
+				state: "running",
+				attempts: first.attempts + 1,
+				updatedAt: Date.now()
+			};
+			await this.write(job);
+			return job;
+		});
+	}
+	settle(job, state, details = {}) {
+		return this.locked(async () => {
+			const current = await this.read(job.id);
+			const next = {
+				...job,
+				payload: current?.payload ?? job.payload,
+				state,
+				updatedAt: Date.now()
+			};
+			delete next.lastError;
+			delete next.lastErrorKind;
+			delete next.nextRunAt;
+			delete next.result;
+			await this.write({
+				...next,
+				...details
+			});
+		});
+	}
+	pauseDream(paused) {
+		return this.locked(async () => {
+			const result = [];
+			for (const job of await this.list()) if (job.kind === "dream" && (job.state === "queued" || job.state === "running")) {
+				const next = {
+					...job,
+					payload: {
+						...job.payload,
+						paused
+					},
+					updatedAt: Date.now()
+				};
+				delete next.payload["budget_exhausted"];
+				delete next.payload["budget_epoch"];
+				await this.write(next);
+				result.push(next);
+			}
+			return result;
+		});
+	}
+	retry(id) {
+		return this.locked(async () => {
+			const job = await this.read(id);
+			if (job === null || job.state !== "failed") throw new JobError("validation", "只能重试已失败的任务；请从 /acn-status 复制任务 ID。");
+			const next = {
+				...job,
+				state: "queued",
+				attempts: 0,
+				updatedAt: Date.now()
+			};
+			delete next.lastError;
+			delete next.lastErrorKind;
+			delete next.nextRunAt;
+			await this.write(next);
+			return next;
+		});
+	}
+};
+//#endregion
+export { runnableJob as n, JobQueue as t };

package/lib/regular-file-BFpqMoub.js

@@ -0,0 +1,136 @@
+import { t as KnowledgeError } from "./errors-Bp_2WXBr.js";
+import fs from "node:fs/promises";
+import { constants } from "node:fs";
+//#region src/knowledge/safety.ts
+const invisibleRanges = [
+	[0, 31],
+	[127, 159],
+	[173, 173],
+	[847, 847],
+	[1564, 1564],
+	[1757, 1757],
+	[1807, 1807],
+	[2192, 2193],
+	[2274, 2274],
+	[6158, 6158],
+	[7114, 7117],
+	[119155, 119162],
+	[8203, 8207],
+	[8234, 8238],
+	[8288, 8303],
+	[65024, 65039],
+	[65279, 65279],
+	[65529, 65531],
+	[917760, 917999]
+];
+function invisible(value) {
+	return Array.from(value).some((char) => {
+		if ([
+			"	",
+			"\n",
+			"\r"
+		].includes(char)) return false;
+		const point = char.codePointAt(0);
+		return point !== void 0 && invisibleRanges.some(([first, last]) => point >= first && point <= last);
+	});
+}
+const patterns = [
+	["ignore", "instructions"],
+	["you are now"],
+	["do not tell", "user"],
+	["system prompt", "override"],
+	[
+		"override",
+		"previous",
+		"rules"
+	],
+	["disregard", "instructions"],
+	["disregard", "rules"],
+	[
+		"act as if",
+		"no",
+		"restrictions"
+	],
+	[
+		"act as though",
+		"no",
+		"rules"
+	],
+	...[
+		"key",
+		"token",
+		"secret",
+		"password",
+		"credential"
+	].map((term) => [
+		"curl",
+		"$",
+		term
+	]),
+	["curl", "api_key"],
+	["curl", "token="],
+	...[
+		"key",
+		"token",
+		"secret"
+	].map((term) => [
+		"wget",
+		"$",
+		term
+	]),
+	...[
+		".env",
+		"credentials",
+		"id_rsa",
+		".netrc",
+		".npmrc",
+		".pypirc"
+	].map((term) => ["curl", term]),
+	...[
+		".env",
+		"credentials",
+		"id_rsa"
+	].map((term) => ["wget", term]),
+	...[
+		".env",
+		"credentials",
+		".netrc",
+		".pgpass",
+		".npmrc",
+		".pypirc",
+		"id_rsa",
+		".aws/config"
+	].map((term) => ["cat", term]),
+	["authorized_keys"],
+	["$home/.ssh"],
+	["~/.ssh"]
+];
+function validateClaimText(fields) {
+	for (const [field, value] of Object.entries(fields)) {
+		if (value.trim() === "") throw new KnowledgeError("validation", `Claim ${field} must not be empty.`);
+		if (textSafetyIssue(value) !== null) throw new KnowledgeError("safety", `Claim ${field} failed the safety scan.`);
+	}
+}
+function textSafetyIssue(value) {
+	if (invisible(value)) return "invisible_unicode";
+	const normalized = value.toLowerCase().replace(/\s/gu, " ").replace(/ +/g, " ");
+	return patterns.some((terms) => terms.every((term) => normalized.includes(term))) ? "threat_pattern" : null;
+}
+//#endregion
+//#region src/store/regular-file.ts
+async function openSingleFile(path, invalid) {
+	const before = await fs.lstat(path);
+	if (!before.isFile() || before.isSymbolicLink() || before.nlink !== 1) throw invalid();
+	const file = await fs.open(path, constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0) | (constants.O_NONBLOCK ?? 0));
+	try {
+		const opened = await file.stat();
+		const current = await fs.lstat(path);
+		if (!opened.isFile() || opened.nlink !== 1 || current.isSymbolicLink() || before.dev !== opened.dev || before.ino !== opened.ino || current.dev !== opened.dev || current.ino !== opened.ino) throw invalid();
+		return file;
+	} catch (error) {
+		await file.close();
+		throw error;
+	}
+}
+//#endregion
+export { validateClaimText as n, openSingleFile as t };

package/lib/render-CJaVcKKC.js

@@ -0,0 +1,48 @@
+import { readFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import nunjucks from "nunjucks";
+//#region src/prompt/render.ts
+const templateNames = [
+	"claim_dream.j2",
+	"claim_dream_legacy.j2",
+	"dream_compaction.j2",
+	"dream_evidence.j2",
+	"knowledge.j2",
+	"session_recap.j2",
+	"inbox_policy_update_internalize.j2",
+	"inbox_claim_attribute_update_internalize.j2",
+	"what_is_claim.j2",
+	"what_is_dispute.j2",
+	"what_is_policy.j2"
+];
+var TemplateLoader = class extends nunjucks.Loader {
+	sources;
+	constructor(sources) {
+		super();
+		this.sources = sources;
+	}
+	getSource(name) {
+		const src = this.sources[name];
+		if (src === void 0) throw new Error("Unknown knowledge template.");
+		return {
+			src: src.endsWith("\n") ? src.slice(0, -1) : src,
+			path: name,
+			noCache: false
+		};
+	}
+};
+function promptRenderer(sources) {
+	const environment = new nunjucks.Environment(new TemplateLoader(sources), {
+		autoescape: false,
+		throwOnUndefined: true
+	});
+	return (name, context) => environment.render(name, context);
+}
+async function loadPromptRenderer() {
+	const root = dirname(fileURLToPath(import.meta.resolve("@ftai/dsh-plugin-acn/package.json")));
+	const sources = await Promise.all(templateNames.map(async (name) => [name, await readFile(join(root, "prompts", name), "utf8")]));
+	return promptRenderer(Object.fromEntries(sources));
+}
+//#endregion
+export { loadPromptRenderer as t };

package/lib/reported-sets-DdEKdeVb.js

@@ -0,0 +1,122 @@
+import { l as ClaimIdSchema, t as ClaimSchema, u as DisputeIdSchema, y as TimestampSchema } from "./claim-DOAGe8ZK.js";
+import { C as StoreError, c as readYamlOr, d as removeFile, l as writeYamlAtomic, n as withFileLock, s as readYaml, w as hasCode } from "./lock-DbmlKOoX.js";
+import { z } from "zod";
+import fs from "node:fs/promises";
+import { join } from "node:path";
+//#region src/store/entities.ts
+var EntityStore = class {
+	context;
+	directory;
+	schema;
+	idSchema;
+	constructor(context, directory, schema, idSchema) {
+		this.context = context;
+		this.directory = directory;
+		this.schema = schema;
+		this.idSchema = idSchema;
+	}
+	path(id) {
+		return join(this.directory, `${this.idSchema.parse(id)}.yaml`);
+	}
+	async read(id) {
+		const value = await readYaml(this.path(id), this.schema);
+		if (value.id !== id) throw new StoreError("decode", `Entity ID differs from its filename: ${id}`);
+		return value;
+	}
+	async write(value) {
+		const parsed = this.schema.parse(value);
+		await writeYamlAtomic(this.path(parsed.id), parsed, this.schema, this.context.logger);
+		return parsed;
+	}
+	async list() {
+		let entries;
+		try {
+			entries = await fs.readdir(this.directory, { withFileTypes: true });
+		} catch (error) {
+			if (hasCode(error, "ENOENT")) return [];
+			throw error;
+		}
+		const values = [];
+		for (const entry of entries.sort((a, b) => a.name.localeCompare(b.name))) {
+			if (!entry.isFile() || !entry.name.endsWith(".yaml") || entry.name.includes(".tmp.")) continue;
+			const id = entry.name.slice(0, -5);
+			if (!this.idSchema.safeParse(id).success) continue;
+			try {
+				values.push(await this.read(id));
+			} catch (error) {
+				if (error instanceof StoreError && error.kind === "decode") this.context.logger.warn(`Skipped invalid entity file: ${entry.name}`);
+				else throw error;
+			}
+		}
+		return values;
+	}
+	async create(makeId, makeValue) {
+		await fs.mkdir(this.directory, { recursive: true });
+		for (let attempt = 0; attempt < 8; attempt += 1) {
+			const id = this.idSchema.parse(makeId());
+			const path = this.path(id);
+			try {
+				await (await fs.open(path, "wx", 384)).close();
+			} catch (error) {
+				if (hasCode(error, "EEXIST")) continue;
+				throw error;
+			}
+			try {
+				const value = makeValue(id);
+				if (value.id !== id) throw new StoreError("conflict", "Reserved entity ID differs from the value.");
+				return await this.write(value);
+			} catch (error) {
+				await removeFile(path, this.context.logger);
+				throw error;
+			}
+		}
+		throw new StoreError("conflict", "Entity ID collisions exceeded eight attempts.");
+	}
+};
+//#endregion
+//#region src/store/claims.ts
+var ClaimStore = class extends EntityStore {
+	constructor(context) {
+		super(context, context.paths.claims, ClaimSchema, ClaimIdSchema);
+	}
+	async write(value) {
+		const claim = ClaimSchema.parse(value);
+		if (claim.holder !== this.context.agentId) throw new StoreError("ownership", "Cannot write a Claim held by another agent.");
+		return super.write(claim);
+	}
+};
+//#endregion
+//#region src/store/reported-sets.ts
+const ReportedSetsSchema = z.object({ reported_claim_sets: z.record(z.string(), z.object({
+	first_dispute_id: DisputeIdSchema,
+	reported_at: TimestampSchema
+})).default({}).transform((records) => Object.fromEntries(Object.entries(records).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0))) });
+function reportedClaimSetKey(claims) {
+	return [...new Set(claims.map((id) => ClaimIdSchema.parse(id)))].sort().join(" | ");
+}
+var ReportedSetStore = class {
+	context;
+	constructor(context) {
+		this.context = context;
+	}
+	read() {
+		return readYamlOr(this.context.paths.reportedSets, ReportedSetsSchema, () => ReportedSetsSchema.parse({}));
+	}
+	async contains(claims) {
+		return Object.hasOwn((await this.read()).reported_claim_sets, reportedClaimSetKey(claims));
+	}
+	async record(claims, disputeId, reportedAt) {
+		await withFileLock(`${this.context.paths.reportedSets}.lock`, async () => {
+			const value = await this.read();
+			const key = reportedClaimSetKey(claims);
+			if (Object.hasOwn(value.reported_claim_sets, key)) return;
+			value.reported_claim_sets[key] = {
+				first_dispute_id: DisputeIdSchema.parse(disputeId),
+				reported_at: TimestampSchema.parse(reportedAt)
+			};
+			await writeYamlAtomic(this.context.paths.reportedSets, value, ReportedSetsSchema, this.context.logger);
+		}, { timeoutMs: this.context.lockTimeoutMs });
+	}
+};
+//#endregion
+export { EntityStore as a, ClaimStore as i, ReportedSetsSchema as n, reportedClaimSetKey as r, ReportedSetStore as t };

package/lib/revision-DeoL_IUN.js

@@ -0,0 +1,11 @@
+import { t as ClaimSchema } from "./claim-DOAGe8ZK.js";
+import { createHash } from "node:crypto";
+//#region src/protocol/revision.ts
+function canonicalJson(value) {
+	return JSON.stringify(ClaimSchema.parse(value));
+}
+function claimRevision(value) {
+	return `sha256-v1:${createHash("sha256").update(canonicalJson(value)).digest("hex")}`;
+}
+//#endregion
+export { claimRevision as n, canonicalJson as t };

package/lib/scheduler-MaUEbXr3.js

@@ -0,0 +1,64 @@
+import { r as UploadStore } from "./uploads-BCA2p92b.js";
+import { t as UploadDelivery } from "./deliver-BuYQaPRW.js";
+//#region src/upload/scheduler.ts
+var UploadScheduler = class {
+	knowledge;
+	intervalMs;
+	pending;
+	requested = false;
+	closed = false;
+	abort = new AbortController();
+	timer;
+	unsubscribe;
+	delivery;
+	constructor(knowledge, intervalMs = 10 * 6e4) {
+		this.knowledge = knowledge;
+		this.intervalMs = intervalMs;
+		this.delivery = new UploadDelivery(knowledge.context(), knowledge.team);
+	}
+	start() {
+		if (this.knowledge.team === null) return;
+		this.unsubscribe = this.knowledge.onClaimsChanged(() => {
+			this.kick();
+		});
+		this.timer = setInterval(() => {
+			this.kick();
+		}, this.intervalMs);
+		this.timer.unref();
+		this.kick();
+	}
+	kick() {
+		if (this.closed || this.knowledge.team === null) return;
+		this.requested = true;
+		if (this.pending !== void 0) return;
+		const work = this.run().catch(() => {
+			if (!this.closed) this.knowledge.logger.warn("Could not finish local upload bookkeeping; pending delivery is retained.");
+		});
+		this.pending = work;
+		work.finally(() => {
+			if (this.pending === work) {
+				this.pending = void 0;
+				if (this.requested && !this.closed) this.kick();
+			}
+		});
+	}
+	async run() {
+		while (this.requested && !this.closed) {
+			this.requested = false;
+			const queue = await new UploadStore(this.knowledge.context()).read();
+			if (queue.claims.length > 0 || queue.disputes.length > 0) await this.delivery.deliver(this.abort.signal);
+		}
+	}
+	async flush() {
+		await this.pending;
+	}
+	async close() {
+		this.closed = true;
+		this.unsubscribe?.();
+		if (this.timer !== void 0) clearInterval(this.timer);
+		this.abort.abort();
+		await this.pending;
+	}
+};
+//#endregion
+export { UploadScheduler as t };