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

package/lib/lock-DbmlKOoX.js

@@ -0,0 +1,332 @@
+import { z } from "zod";
+import { randomBytes } from "node:crypto";
+import fs from "node:fs/promises";
+import { basename, dirname, join, resolve } from "node:path";
+import { parse, stringify } from "yaml";
+import { setTimeout } from "node:timers/promises";
+import { AsyncLocalStorage } from "node:async_hooks";
+import { performance } from "node:perf_hooks";
+import lockfile from "proper-lockfile";
+//#region src/store/errors.ts
+var StoreError = class extends Error {
+	kind;
+	constructor(kind, message, options) {
+		super(message, options);
+		this.kind = kind;
+		this.name = "StoreError";
+	}
+};
+var LockTimeoutError = class extends StoreError {
+	constructor(path) {
+		super("lock_timeout", `Timed out acquiring lock: ${path}`);
+		this.name = "LockTimeoutError";
+	}
+};
+function hasCode(error, code) {
+	return typeof error === "object" && error !== null && "code" in error && error.code === code;
+}
+//#endregion
+//#region src/worker/types.ts
+const JobKindSchema = z.enum([
+	"finalize",
+	"recap",
+	"inbox",
+	"dream"
+]);
+const JobSchema = z.strictObject({
+	schemaVersion: z.literal(1),
+	id: z.string().regex(/^[a-zA-Z0-9_-]+$/),
+	kind: JobKindSchema,
+	sessionId: z.string().regex(/^[a-zA-Z0-9_-]+$/).optional(),
+	payload: z.record(z.string(), z.json()),
+	state: z.enum([
+		"queued",
+		"running",
+		"succeeded",
+		"failed"
+	]),
+	attempts: z.number().int().nonnegative(),
+	createdAt: z.number().int().nonnegative(),
+	updatedAt: z.number().int().nonnegative(),
+	ordinal: z.number().int().nonnegative().optional(),
+	nextRunAt: z.number().int().nonnegative().optional(),
+	lastError: z.string().optional(),
+	lastErrorKind: z.string().optional(),
+	result: z.json().optional()
+});
+const jobPriority = {
+	finalize: 0,
+	recap: 1,
+	inbox: 2,
+	dream: 3
+};
+var JobError = class extends Error {
+	kind;
+	retryable;
+	retryAfterMs;
+	constructor(kind, message, retryable = false, retryAfterMs) {
+		super(message);
+		this.kind = kind;
+		this.retryable = retryable;
+		this.retryAfterMs = retryAfterMs;
+	}
+};
+var Preempted = class extends JobError {
+	constructor() {
+		super("preempted", "Recap superseded by Finalize before prepared.");
+	}
+};
+var DreamStopped = class extends JobError {
+	constructor() {
+		super("dream_stopped", "Dream 已停在可恢复边界，已生效修改保留。");
+	}
+};
+var DreamYield = class extends JobError {
+	constructor() {
+		super("dream_yield", "Dream 已让位给高优先级任务，草稿和进度保留。");
+	}
+};
+//#endregion
+//#region src/store/rename.ts
+async function renameFile(source, destination) {
+	for (let attempt = 0;; attempt += 1) try {
+		await fs.rename(source, destination);
+		return;
+	} catch (error) {
+		if (process.platform !== "win32" || attempt >= 5 || ![
+			"EPERM",
+			"EACCES",
+			"EBUSY"
+		].some((code) => hasCode(error, code))) throw error;
+		await setTimeout(10 * 2 ** attempt);
+	}
+}
+//#endregion
+//#region src/store/atomic.ts
+async function syncDirectory(path, logger) {
+	try {
+		const directory = await fs.open(path, "r");
+		try {
+			await directory.sync();
+		} finally {
+			await directory.close();
+		}
+	} catch {
+		logger.debug(`Parent directory sync unavailable: ${path}`);
+	}
+}
+async function writeTextAtomic(path, content, logger) {
+	await publishText(path, content, logger, false);
+}
+function writeTextAtomicIfAbsent(path, content, logger) {
+	return publishText(path, content, logger, true);
+}
+async function publishText(path, content, logger, exclusive) {
+	let temporary;
+	try {
+		await fs.mkdir(dirname(path), { recursive: true });
+		for (let attempt = 0; attempt < 16; attempt += 1) {
+			const candidate = join(dirname(path), `${basename(path)}.tmp.${process.pid}.${randomBytes(8).toString("hex")}`);
+			let file;
+			try {
+				file = await fs.open(candidate, "wx", 384);
+			} catch (error) {
+				if (hasCode(error, "EEXIST")) continue;
+				throw error;
+			}
+			temporary = candidate;
+			try {
+				await file.writeFile(content, "utf8");
+				await file.sync();
+			} finally {
+				await file.close();
+			}
+			break;
+		}
+		if (temporary === void 0) throw new StoreError("io", "Could not create an exclusive temporary file.");
+		if (exclusive) {
+			try {
+				await fs.link(temporary, path);
+			} catch (error) {
+				if (!hasCode(error, "EEXIST")) throw error;
+				await fs.unlink(temporary);
+				return false;
+			}
+			await fs.unlink(temporary);
+		} else await renameFile(temporary, path);
+		await syncDirectory(dirname(path), logger);
+		return true;
+	} catch (error) {
+		if (temporary !== void 0) await fs.rm(temporary, { force: true }).catch(() => {
+			logger.debug(`Could not remove temporary file: ${temporary}`);
+		});
+		throw new StoreError("io", `Atomic write failed: ${path}`, { cause: error });
+	}
+}
+async function removeFile(path, logger) {
+	try {
+		await fs.unlink(path);
+		await syncDirectory(dirname(path), logger);
+	} catch (error) {
+		if (!hasCode(error, "ENOENT")) throw new StoreError("io", `Cannot remove file: ${path}`, { cause: error });
+	}
+}
+async function cleanupAtomicTemps(root, logger, options = {}) {
+	const cutoff = (options.nowMs ?? Date.now()) - (options.olderThanMs ?? 36e5);
+	let entries;
+	try {
+		entries = await fs.readdir(root, { withFileTypes: true });
+	} catch (error) {
+		if (hasCode(error, "ENOENT")) return 0;
+		throw error;
+	}
+	let removed = 0;
+	for (const entry of entries) {
+		const path = join(root, entry.name);
+		if (entry.isDirectory() && !entry.name.endsWith(".lock")) removed += await cleanupAtomicTemps(path, logger, options);
+		else if (entry.isFile() && entry.name.includes(".tmp.")) try {
+			if ((await fs.stat(path)).mtimeMs <= cutoff) {
+				await removeFile(path, logger);
+				removed += 1;
+			}
+		} catch (error) {
+			if (!hasCode(error, "ENOENT")) throw error;
+		}
+	}
+	return removed;
+}
+//#endregion
+//#region src/store/yaml.ts
+function encodeJson(schema, value) {
+	return JSON.stringify(schema.parse(value));
+}
+function encodeYaml(schema, value) {
+	try {
+		return stringify(JSON.parse(encodeJson(schema, value)), {
+			indent: 2,
+			indentSeq: false,
+			lineWidth: 0
+		});
+	} catch {
+		throw new StoreError("encode", "Cannot encode YAML value.");
+	}
+}
+function decodeYaml(schema, text) {
+	try {
+		const value = parse(text, { maxAliasCount: 100 });
+		return schema.parse(value);
+	} catch {
+		throw new StoreError("decode", "Invalid YAML document.");
+	}
+}
+async function readYaml(path, schema) {
+	let text;
+	try {
+		text = await fs.readFile(path, "utf8");
+	} catch (error) {
+		throw new StoreError("io", `Cannot read file: ${path}`, { cause: error });
+	}
+	try {
+		return decodeYaml(schema, text);
+	} catch {
+		throw new StoreError("decode", `Invalid YAML document: ${path}`);
+	}
+}
+async function readYamlOr(path, schema, fallback) {
+	try {
+		return await readYaml(path, schema);
+	} catch (error) {
+		if (error instanceof StoreError && hasCode(error.cause, "ENOENT")) return fallback();
+		throw error;
+	}
+}
+async function writeYamlAtomic(path, value, schema, logger) {
+	await writeTextAtomic(path, encodeYaml(schema, value), logger);
+}
+//#endregion
+//#region src/store/lock.ts
+const heldLocks = new AsyncLocalStorage();
+async function acquireFileLease(path, options = {}) {
+	options.signal?.throwIfAborted();
+	const lockPath = resolve(path);
+	const timeout = options.timeoutMs ?? 3e4;
+	const stale = options.staleMs ?? 3e4;
+	if (!Number.isFinite(timeout) || timeout < 0 || !Number.isFinite(stale) || stale < 5e3) throw new StoreError("lock_order", "Invalid lock timing options.");
+	await fs.mkdir(dirname(lockPath), { recursive: true });
+	const deadline = performance.now() + timeout;
+	let compromised;
+	let pendingDeleteRetries = 0;
+	for (;;) {
+		options.signal?.throwIfAborted();
+		try {
+			const release = await lockfile.lock(lockPath, {
+				realpath: false,
+				lockfilePath: lockPath,
+				stale,
+				retries: 0,
+				onCompromised: (error) => {
+					compromised = error;
+				}
+			});
+			if (options.signal?.aborted) {
+				await release();
+				options.signal.throwIfAborted();
+			}
+			return {
+				check: () => {
+					if (compromised !== void 0) throw new StoreError("lock_compromised", "Lock ownership was lost.", { cause: compromised });
+				},
+				release
+			};
+		} catch (error) {
+			options.signal?.throwIfAborted();
+			if (process.platform === "win32" && hasCode(error, "EPERM") && typeof error === "object" && error !== null && "syscall" in error && error.syscall === "mkdir" && pendingDeleteRetries < 5 && performance.now() < deadline) {
+				await setTimeout(Math.min(10 * 2 ** pendingDeleteRetries++, Math.max(1, deadline - performance.now())), void 0, { signal: options.signal });
+				continue;
+			}
+			if (!hasCode(error, "ELOCKED")) throw new StoreError("io", `Cannot acquire lock: ${lockPath}`, { cause: error });
+			if (performance.now() >= deadline) throw new LockTimeoutError(lockPath);
+			await setTimeout(Math.min(25, Math.max(1, deadline - performance.now())), void 0, { signal: options.signal });
+		}
+	}
+}
+async function withFileLock(path, action, options = {}) {
+	const lockPath = resolve(path);
+	const held = heldLocks.getStore() ?? [];
+	if (held.some((previous) => previous >= lockPath)) throw new StoreError("lock_order", `Lock order violation: ${lockPath}`);
+	const lease = await acquireFileLease(lockPath, options);
+	let outcome;
+	try {
+		const result = await heldLocks.run([...held, lockPath], action);
+		lease.check();
+		outcome = {
+			ok: true,
+			value: result
+		};
+	} catch (error) {
+		outcome = {
+			ok: false,
+			error
+		};
+	}
+	try {
+		await lease.release();
+	} catch (error) {
+		if (outcome.ok) outcome = {
+			ok: false,
+			error: new StoreError("lock_compromised", `Cannot release lock: ${lockPath}`, { cause: error })
+		};
+	}
+	if (!outcome.ok) throw outcome.error;
+	return outcome.value;
+}
+function withFileLocks(paths, action, options = {}) {
+	const ordered = [...new Set(paths.map((path) => resolve(path)))].sort();
+	const acquire = (index) => {
+		const path = ordered[index];
+		return path === void 0 ? action() : withFileLock(path, () => acquire(index + 1), options);
+	};
+	return acquire(0);
+}
+//#endregion
+export { StoreError as C, LockTimeoutError as S, JobError as _, encodeJson as a, Preempted as b, readYamlOr as c, removeFile as d, writeTextAtomic as f, DreamYield as g, DreamStopped as h, decodeYaml as i, writeYamlAtomic as l, renameFile as m, withFileLock as n, encodeYaml as o, writeTextAtomicIfAbsent as p, withFileLocks as r, readYaml as s, acquireFileLease as t, cleanupAtomicTemps as u, JobKindSchema as v, hasCode as w, jobPriority as x, JobSchema as y };

package/lib/pages-BEWC3kmZ.js

@@ -0,0 +1,51 @@
+import { S as timestampNanos, i as effectiveUpdatedAt } from "./claim-DOAGe8ZK.js";
+import { t as KnowledgeError } from "./errors-Bp_2WXBr.js";
+import "./types-C2ST2Zdg.js";
+//#region src/knowledge/pages.ts
+function boundedText(value, limit) {
+	const chars = Array.from(value);
+	return {
+		text: chars.slice(0, limit).join(""),
+		truncated: chars.length > limit
+	};
+}
+function validatePage(offset, limit, maximum = 100) {
+	if (!Number.isSafeInteger(offset) || offset < 0 || !Number.isSafeInteger(limit) || limit < 1 || limit > maximum) throw new KnowledgeError("validation", `Offset must be nonnegative and limit must be within 1..${maximum}.`);
+}
+function page(items, offset, limit) {
+	const selected = items.slice(offset, offset + limit);
+	const end = Math.min(offset + selected.length, items.length);
+	return {
+		items: selected,
+		offset,
+		limit,
+		omitted: items.length - end,
+		next_offset: end < items.length ? end : null
+	};
+}
+function sortClaims(claims) {
+	return [...claims].sort((a, b) => {
+		const delta = timestampNanos(effectiveUpdatedAt(b)) - timestampNanos(effectiveUpdatedAt(a));
+		return delta === 0n ? a.id < b.id ? -1 : a.id > b.id ? 1 : 0 : delta > 0n ? 1 : -1;
+	});
+}
+function claimListPage(claims, query) {
+	const offset = query.offset ?? 0;
+	const limit = query.limit ?? 20;
+	validatePage(offset, limit);
+	const term = query.query?.trim().toLowerCase();
+	return page(sortClaims(claims.filter((claim) => (query.includeDeprecated || claim.status !== "deprecated") && (!term || [
+		claim.name,
+		claim.scope,
+		claim.statement
+	].some((value) => value.toLowerCase().includes(term))))).map((claim) => ({
+		id: claim.id,
+		name: boundedText(claim.name, 120),
+		scope: boundedText(claim.scope, 240),
+		confidence: claim.confidence,
+		status: claim.status,
+		updated_at: effectiveUpdatedAt(claim)
+	})), offset, limit);
+}
+//#endregion
+export { validatePage as a, sortClaims as i, claimListPage as n, page as r, boundedText as t };

package/lib/paths-B7NI9Ano.js

@@ -0,0 +1,157 @@
+import { c as AgentIdSchema, d as InboxIdSchema, h as TraceIdSchema, l as ClaimIdSchema, u as DisputeIdSchema } from "./claim-DOAGe8ZK.js";
+import { C as StoreError } from "./lock-DbmlKOoX.js";
+import { createHash } from "node:crypto";
+import { join, resolve } from "node:path";
+import { homedir } from "node:os";
+//#region src/local-name.ts
+function portableLocalName(value) {
+	return !/^(?:con|prn|aux|nul|com[1-9]|lpt[1-9])(?:\.|$)/i.test(value);
+}
+//#endregion
+//#region src/store/path-names.ts
+function invalidStorageName(name, platform = process.platform) {
+	return platform === "win32" && !portableLocalName(name);
+}
+function assertStorageName(name) {
+	if (invalidStorageName(name)) throw new StoreError("io", "Windows reserved names cannot be used for an Agent ID or upstream directory.");
+}
+//#endregion
+//#region src/store/paths.ts
+function expandHomePath(home) {
+	return home === "~" ? homedir() : /^~[/\\]/.test(home) ? join(homedir(), home.slice(2)) : home;
+}
+function agentHomePath(home, agentId, upstream = "personal") {
+	const id = AgentIdSchema.parse(agentId);
+	if (!/^[a-z0-9_-]+$/.test(upstream)) throw new Error("Invalid upstream identifier.");
+	assertStorageName(upstream);
+	const directory = createHash("sha256").update("agent").update(Uint8Array.of(0)).update(id).digest("hex");
+	return join(resolve(expandHomePath(home)), "upstreams", upstream, "agents", directory);
+}
+function safeKey(value) {
+	if (!/^[a-zA-Z0-9_-]+$/.test(value)) throw new Error("Invalid local document identifier.");
+	assertStorageName(value);
+	return value;
+}
+var AgentPaths = class {
+	root;
+	constructor(agentHome) {
+		this.root = resolve(agentHome);
+	}
+	get claims() {
+		return join(this.root, "claims");
+	}
+	get traces() {
+		return join(this.root, "traces");
+	}
+	get disputes() {
+		return join(this.root, "disputes");
+	}
+	get inbox() {
+		return join(this.root, "inbox");
+	}
+	get uploads() {
+		return join(this.root, "maintainer_uploads");
+	}
+	get pendingUploads() {
+		return join(this.uploads, "pending.yaml");
+	}
+	get pendingUploadsLock() {
+		return join(this.uploads, "pending.lock");
+	}
+	get rejectedDisputes() {
+		return join(this.uploads, "rejected_disputes.yaml");
+	}
+	get deliveryStatus() {
+		return join(this.uploads, "delivery_status.yaml");
+	}
+	get deliveryLock() {
+		return join(this.uploads, "delivery.lock");
+	}
+	get knowledgeLock() {
+		return join(this.root, "knowledge_apply.lock");
+	}
+	get claimEditPending() {
+		return join(this.root, "claim_edit_pending.yaml");
+	}
+	get reportedSets() {
+		return join(this.disputes, "reported_claim_sets.yaml");
+	}
+	get jobs() {
+		return join(this.root, "jobs");
+	}
+	get workerLock() {
+		return join(this.jobs, "worker.lock");
+	}
+	get jobQueueLock() {
+		return join(this.jobs, "queue.lock");
+	}
+	get sessions() {
+		return join(this.root, "sessions");
+	}
+	get lastRoute() {
+		return join(this.root, "runtime", "last_route.yaml");
+	}
+	get dreamWorkspace() {
+		return join(this.root, "runtime", "dream_workspace.yaml");
+	}
+	get llmCalls() {
+		return join(this.root, "runtime", "llm-calls");
+	}
+	get dreamRoot() {
+		return join(this.root, "dream");
+	}
+	get dreamState() {
+		return join(this.root, "runtime", "supervisor", "dream_state.yaml");
+	}
+	get dreamPending() {
+		return join(this.root, "runtime", "supervisor", "dream_pending.yaml");
+	}
+	dreamJob(id) {
+		return join(this.dreamRoot, safeKey(id));
+	}
+	dreamFinal(id) {
+		return join(this.root, "runtime", "supervisor", "dream", `${safeKey(id)}.yaml`);
+	}
+	dreamExecution(id, validation) {
+		if (!/^[0-9a-f]{64}$/.test(validation)) throw new Error("Invalid Dream validation identifier.");
+		return join(this.dreamJob(id), "executions", `${validation}.yaml`);
+	}
+	transcript(id) {
+		return join(this.session(id), "transcript.jsonl");
+	}
+	transcriptPending(id) {
+		return join(this.session(id), "transcript-pending");
+	}
+	claim(id) {
+		return join(this.claims, `${ClaimIdSchema.parse(id)}.yaml`);
+	}
+	trace(id) {
+		return join(this.traces, `${TraceIdSchema.parse(id)}.yaml`);
+	}
+	dispute(id) {
+		return join(this.disputes, `${DisputeIdSchema.parse(id)}.yaml`);
+	}
+	pendingInbox(id) {
+		return join(this.inbox, `${InboxIdSchema.parse(id)}.yaml`);
+	}
+	doneInbox(id) {
+		return join(this.inbox, `${InboxIdSchema.parse(id)}.done.yaml`);
+	}
+	inboxEffect(id) {
+		return join(this.inbox, "effects", `${InboxIdSchema.parse(id)}.yaml`);
+	}
+	session(id) {
+		return join(this.root, "sessions", safeKey(id));
+	}
+	sessionState(id) {
+		return join(this.session(id), "state.yaml");
+	}
+	finalizeCheckpoint(id) {
+		return join(this.session(id), "finalize_checkpoint.yaml");
+	}
+	job(id) {
+		return join(this.jobs, `${safeKey(id)}.yaml`);
+	}
+};
+//#endregion
+export { assertStorageName as a, safeKey as i, agentHomePath as n, invalidStorageName as o, expandHomePath as r, AgentPaths as t };