@gitroll/tacitt-cli 0.0.0-stage → 0.1.0

package/dist/model-7Nu7szNP.mjs

@@ -0,0 +1,41 @@
+import "./src-CPPjOyHZ.mjs";
+//#region packages/harnesses/src/discovery/model.ts
+const discoveryBounds = {
+	entries: 1e5,
+	depth: 32,
+	parsers: 2,
+	metadataBytes: 262144,
+	journalBytes: 16777216,
+	chunkBytes: 65536,
+	headChunkBytes: 16384,
+	tailBytes: 16384,
+	warnings: 200
+};
+const errorCode = (error) => typeof error === "object" && error !== null && "code" in error && typeof error.code === "string" ? error.code : void 0;
+const isRecord = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+const checkDiscoveryAbort = (signal) => {
+	if (signal?.aborted) throw new Error("DISCOVERY_CANCELED");
+};
+function unresolvedMetadata(harness, warning) {
+	return {
+		path: null,
+		title: `Unresolved workspace (${harness})`,
+		sourceSessionId: null,
+		createdAt: null,
+		lastInteractionAt: null,
+		warnings: ["UNRESOLVED_WORKSPACE", warning],
+		decodedBytes: 0,
+		decodedDigest: null
+	};
+}
+var DiscoveryWarnings = class {
+	counts = /* @__PURE__ */ new Map();
+	add(code, count = 1) {
+		this.counts.set(code, (this.counts.get(code) ?? 0) + count);
+	}
+	list() {
+		return [...this.counts].sort(([left], [right]) => left.localeCompare(right)).slice(0, discoveryBounds.warnings).map(([code, count]) => `${code}:${count}`);
+	}
+};
+//#endregion
+export { isRecord as a, errorCode as i, checkDiscoveryAbort as n, unresolvedMetadata as o, discoveryBounds as r, DiscoveryWarnings as t };

package/dist/operation-executor.mjs

@@ -0,0 +1,181 @@
+import { a as createRuntime, f as longCommands, i as invoke, m as startupFailure, n as readOperation, r as waitOperation, s as executorRequestSchema, u as parseOptions } from "./query-Da-KDbSV.mjs";
+import { Gt as safeField, Ht as ApplicationError, Wt as safeCode } from "./locate-Bn32k2se.mjs";
+import "./src-CPPjOyHZ.mjs";
+import { z } from "zod";
+import { setTimeout } from "node:timers/promises";
+//#region apps/cli/src/operation/executor.ts
+process.umask(63);
+let runtime;
+let detached = false;
+let started = false;
+let operationId;
+let stopRequested = false;
+let stopping;
+const stop = () => {
+	stopRequested = true;
+	return stopping ??= runtime?.close() ?? Promise.resolve();
+};
+const send = (event) => new Promise((resolve, reject) => {
+	if (!process.connected) {
+		if (detached) resolve();
+		else reject(new ApplicationError("OPERATION_CANCELED"));
+		return;
+	}
+	process.send?.(event, (error) => error ? reject(error) : resolve());
+});
+const parentLost = () => {
+	if (!detached) stop().catch(() => {
+		process.exitCode = 1;
+	});
+};
+process.on("disconnect", parentLost);
+process.on("SIGINT", () => {
+	detached = false;
+	parentLost();
+});
+process.on("SIGTERM", () => {
+	detached = false;
+	parentLost();
+});
+process.on("message", (message) => {
+	if (typeof message === "object" && message !== null && "detach" in message && message.detach === true) {
+		if (!operationId) return;
+		detached = true;
+		send({
+			event: "detached",
+			operationId
+		}).then(() => {
+			if (process.connected) process.disconnect?.();
+		}).catch((error) => {
+			try {
+				runtime?.diagnostics.onFailure("detach-ack", error, operationId);
+			} catch {
+				try {
+					process.stderr.write("LOCAL_DIAGNOSTICS_UNAVAILABLE: detach acknowledgement diagnostic failed.\n");
+				} catch {}
+			} finally {
+				detached = false;
+				parentLost();
+			}
+		});
+		return;
+	}
+	if (started) return;
+	started = true;
+	execute(message);
+});
+async function execute(message) {
+	try {
+		const request = executorRequestSchema.parse(message);
+		if (!longCommands.has(request.command)) throw new ApplicationError("INVALID_ARGUMENTS");
+		let diagnosticCount = 0;
+		runtime = await createRuntime(parseOptions(request.args), {
+			getOperationId: () => operationId,
+			onSafeDiagnostic: (diagnostic) => {
+				if (diagnosticCount++ >= 32 || !process.connected) return;
+				send({
+					event: "diagnostic",
+					...diagnostic
+				}).catch((error) => {
+					process.stderr.write(`${safeCode(error)}: diagnostic transport failed.\n`);
+				});
+			}
+		});
+		if (stopRequested || !process.connected && !detached) throw new ApplicationError("OPERATION_CANCELED");
+		const result = await invoke(runtime, request.command, request.input);
+		const record = z.record(z.string(), z.unknown()).nullable().parse(result);
+		const packagingId = z.object({ id: z.string() }).nullable().parse(record?.["operation"] ?? null)?.id;
+		const discoveryId = z.object({ id: z.string() }).nullable().parse(record?.["discoveryOperation"] ?? null)?.id;
+		const id = request.command === "account.signIn" ? record?.["operationId"] : request.command === "inspection.start" ? record?.["scanId"] : request.command === "workflow.package" ? packagingId : request.command === "workflow.resume" && record?.["phase"] === "packaging" ? packagingId : discoveryId;
+		if (typeof id !== "string") {
+			if (request.command === "account.signIn" && record?.["state"] === "signed-in") {
+				await runtime.close();
+				await send({
+					event: "completed",
+					operationId: "",
+					result
+				});
+				return;
+			}
+			throw new ApplicationError("INVALID_OPERATION");
+		}
+		operationId = id;
+		await send({
+			event: "started",
+			operationId,
+			result
+		});
+		await runtime.application.settle();
+		if (request.command === "account.signIn") {
+			let settled = false;
+			let failure;
+			const authorization = runtime.account.settle().then(() => {
+				settled = true;
+			}, (error) => {
+				failure = error;
+				settled = true;
+			});
+			let previous = "";
+			while (!settled && !stopRequested) {
+				const account = await runtime.account.status();
+				const serialized = JSON.stringify(account);
+				if (account.state === "authorizing" && serialized !== previous) {
+					await send({
+						event: "progress",
+						operationId,
+						result: account
+					});
+					previous = serialized;
+				}
+				await setTimeout(200);
+			}
+			await authorization;
+			if (failure !== void 0) throw failure;
+		}
+		let final = await readOperation(runtime, operationId);
+		while (final.status === "running" && !stopRequested) final = (await waitOperation(runtime, operationId, 3e4)).operation;
+		await runtime.close();
+		await send({
+			event: "completed",
+			operationId,
+			result: final
+		});
+	} catch (error) {
+		const code = error instanceof z.ZodError ? "INVALID_ARGUMENTS" : safeCode(error);
+		runtime?.diagnostics.onFailure("execution", error, operationId);
+		process.stderr.write(`${JSON.stringify({
+			event: "executor.failed",
+			code,
+			stage: "execution",
+			operationId
+		})}\n`);
+		await send({
+			event: "error",
+			code,
+			field: safeField(error),
+			detail: startupFailure(error instanceof z.ZodError ? new ApplicationError("INVALID_ARGUMENTS", void 0, { cause: error }) : error).trim().slice(0, 2048),
+			...operationId ? { operationId } : {}
+		}).catch((sendError) => {
+			process.stderr.write(`${JSON.stringify({
+				event: "executor.failed",
+				code: safeCode(sendError),
+				stage: "error-response",
+				operationId
+			})}\n`);
+		});
+		process.exitCode = 1;
+	} finally {
+		await runtime?.close().catch((error) => {
+			process.stderr.write(`${JSON.stringify({
+				event: "executor.failed",
+				code: safeCode(error),
+				stage: "cleanup",
+				operationId
+			})}\n`);
+			process.exitCode = 1;
+		});
+		if (process.connected) process.disconnect?.();
+	}
+}
+//#endregion
+export {};

package/dist/preview-worker.mjs

@@ -0,0 +1,22 @@
+import { n as assertPreviewHeap, o as previewInputSchema, t as runPreview } from "./run-CCATsHS2.mjs";
+import { parentPort, workerData } from "node:worker_threads";
+//#region packages/harnesses/src/preview/worker/index.ts
+function notify(message) {
+	parentPort?.postMessage(message);
+}
+assertPreviewHeap();
+try {
+	const input = workerData;
+	const { session, cursor } = previewInputSchema.parse(input);
+	notify({
+		kind: "result",
+		page: await runPreview(session, cursor, notify)
+	});
+} catch (error) {
+	notify({
+		kind: "error",
+		code: error instanceof Error && (error.message === "SOURCE_CHANGED" || error.message === "INVALID_PREVIEW_CURSOR") ? error.message : "PREVIEW_WITHHELD"
+	});
+}
+//#endregion
+export {};

package/dist/privacy-validator.mjs

@@ -0,0 +1,46 @@
+import { Dt as privacyResolveSchema, Ot as privacyTermKey, t as locateTerms, wt as decisionCardInputSchema } from "./locate-Bn32k2se.mjs";
+import { z } from "zod";
+//#region apps/cli/src/skill-install/privacy-validator.ts
+const suppliedTerms = z.array(z.object({
+	key: z.string(),
+	type: z.string(),
+	value: z.string()
+}));
+/** Task-local validation; authoritative application ingestion still owns current state. */
+function validateStageAnswer(input, answer) {
+	const task = z.object({
+		terms: suppliedTerms.optional(),
+		card: z.unknown().optional()
+	}).parse(input);
+	if (!task.terms) throw new Error("TASK_INPUT");
+	const expected = new Set(task.terms.map((term) => term.key));
+	const keys = [];
+	if (task.card !== void 0) {
+		const value = z.object({ resolutions: privacyResolveSchema.shape.resolutions }).strict().parse(answer);
+		keys.push(...value.resolutions.map(privacyTermKey));
+	} else {
+		const value = z.object({ cards: z.array(decisionCardInputSchema).min(1) }).strict().parse(answer);
+		if (new Set(value.cards.map((card) => card.id)).size !== value.cards.length) throw new Error("INVALID_SELECTION");
+		keys.push(...value.cards.flatMap((card) => card.termKeys));
+	}
+	const received = new Set(keys);
+	if (keys.length !== expected.size || received.size !== keys.length || keys.some((key) => !expected.has(key))) {
+		const error = /* @__PURE__ */ new Error("INVALID_SELECTION");
+		if (task.card !== void 0) throw error;
+		const seen = /* @__PURE__ */ new Set();
+		const duplicates = /* @__PURE__ */ new Set();
+		for (const key of keys) {
+			if (seen.has(key)) duplicates.add(key);
+			seen.add(key);
+		}
+		throw Object.assign(error, { issues: [{
+			code: "exact_key_coverage",
+			path: ["cards"],
+			missing: [...expected].filter((key) => !received.has(key)),
+			extra: [...received].filter((key) => !expected.has(key)),
+			duplicate: [...duplicates]
+		}] });
+	}
+}
+//#endregion
+export { locateTerms, validateStageAnswer };