@usecontextlayer/ctxe 0.4.1 → 0.4.3

package/dist/cli.mjs

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 
-!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="b91f2a1b-d2ef-5d42-a3e9-b2e7ffe81cc4")}catch(e){}}();
+!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="59a42f57-145c-5f77-afb2-f1f76467783d")}catch(e){}}();
 import { createRequire } from "node:module";
 import * as Sentry from "@sentry/node";
 import * as xi from "node:fs";
@@ -59,7 +59,7 @@ var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
 //#endregion
 //#region package.json
-var version$1 = "0.4.1";
+var version$1 = "0.4.3";
 
 //#endregion
 //#region sentry.ts
@@ -29490,7 +29490,7 @@ function validate(raw, sourcePath) {
 }
 function applyDefaults(input) {
 	return {
-		synthesizerImage: input.synthesizerImage ?? "ghcr.io/usecontextlayer/ctx-sandbox:0.4.1",
+		synthesizerImage: input.synthesizerImage ?? "ghcr.io/usecontextlayer/ctx-sandbox:0.4.3",
 		...input.microsandbox !== void 0 ? { microsandbox: input.microsandbox } : {},
 		...input.oldestConsideredPoint !== void 0 ? { oldestConsideredPoint: input.oldestConsideredPoint } : {},
 		maxSliceSize: input.maxSliceSize ?? 864e5,
@@ -29663,6 +29663,9 @@ async function commitSynthesizerTransaction(repo, input) {
 async function commitRootRepair(repo, input) {
 	return await createCommit(repo, buildRootRepairCommitMessage(input));
 }
+async function commitRootReset(repo, input) {
+	return await createCommit(repo, buildRootResetCommitMessage(input));
+}
 async function pushToOrigin(repo) {
 	if (repo.mode !== "remote") return;
 	await runGit(repo, [
@@ -29792,6 +29795,14 @@ function buildRootRepairCommitMessage(input) {
 		""
 	].join("\n");
 }
+function buildRootResetCommitMessage(input) {
+	return [
+		`ctxe: root reset @ ${input.resetId}`,
+		"",
+		"reset: wipe synthesized content + cursors",
+		""
+	].join("\n");
+}
 function parsePorcelainV1Z(stdout) {
 	const entries = stdout.split("\0").filter((entry) => entry.length > 0);
 	const paths = [];
@@ -30160,7 +30171,7 @@ engine has prepared three files in your working directory:
 - \`./output/\` — the only path that persists back to the host. Anything written
   elsewhere is lost when the sandbox exits.
 
-A \`contextengine\` skill is installed. Read and follow it — it defines how to
+A \`contextengine-synthesizer\` skill is installed. Read and follow it — it defines how to
 synthesize well. Then do the work in \`./synthesizer.md\` and exit.
 
 A clean exit is success; the engine records the run from its own metadata. Do
@@ -31141,6 +31152,44 @@ function latestRunByName(entries) {
 	for (const { record } of entries) if (!latest.has(record.synthesizer)) latest.set(record.synthesizer, record);
 	return latest;
 }
+const GUEST_MEMORY_MIB = 2048;
+const EXEC_INACTIVITY_TIMEOUT_MS = 600 * 1e3;
+const EXEC_MAX_DURATION_MS = 7200 * 1e3;
+const DRAIN_TIMED_OUT = Symbol("drain-timed-out");
+async function drainExecStream(handle, options) {
+	const startedAt = Date.now();
+	let lastEventAt = startedAt;
+	for (;;) {
+		const ceilingDeadline = startedAt + options.maxDurationMs;
+		const inactivityDeadline = lastEventAt + options.inactivityMs;
+		const deadline = Math.min(ceilingDeadline, inactivityDeadline);
+		let timer;
+		const timedOut = new Promise((resolve) => {
+			timer = setTimeout(() => resolve(DRAIN_TIMED_OUT), Math.max(0, deadline - Date.now()));
+		});
+		const pending = handle.recv();
+		let settled;
+		try {
+			settled = await Promise.race([pending, timedOut]);
+		} finally {
+			clearTimeout(timer);
+		}
+		if (settled === DRAIN_TIMED_OUT) {
+			pending.catch(() => {});
+			return {
+				kind: "timed_out",
+				reason: ceilingDeadline <= inactivityDeadline ? "max_duration" : "inactivity"
+			};
+		}
+		if (settled === null) return { kind: "ended" };
+		lastEventAt = Date.now();
+		if (settled.kind === "stderr") options.onStderr(settled.data);
+		else if (settled.kind === "exited") return {
+			exitCode: settled.code,
+			kind: "exited"
+		};
+	}
+}
 var MicrosandboxClaudeExecutor = class {
 	async run(input) {
 		const microsandbox = await import("microsandbox");
@@ -31163,25 +31212,27 @@ var MicrosandboxClaudeExecutor = class {
 				synthesizerBody: input.synthesizerBody
 			});
 			await ensureHostFilesystemReady(fsPlan);
-			let builder = microsandbox.Sandbox.builder(runPlan.sandboxName).image(runPlan.image).replace();
+			let builder = microsandbox.Sandbox.builder(runPlan.sandboxName).image(runPlan.image).memory(GUEST_MEMORY_MIB).replace();
 			builder = applyUserMicrosandboxConfig(builder, runPlan.microsandboxConfig, stderrParts);
 			builder = applySandboxFilesystemPlan(builder, fsPlan);
 			sandbox = await builder.create();
 			const [cmd, ...args] = runPlan.command;
 			const stderrDecoder = new TextDecoder("utf-8", { fatal: false });
 			try {
-				const handle = await sandbox.execStreamWith(cmd, (e) => e.args(args));
-				for await (const event of handle) if (event.kind === "stderr") stderrParts.push(stderrDecoder.decode(event.data, { stream: true }));
-				else if (event.kind === "exited") exitCode = event.code;
+				const drained = await drainExecStream(await sandbox.execStreamWith(cmd, (e) => e.args(args)), {
+					inactivityMs: EXEC_INACTIVITY_TIMEOUT_MS,
+					maxDurationMs: EXEC_MAX_DURATION_MS,
+					onStderr: (data) => stderrParts.push(stderrDecoder.decode(data, { stream: true }))
+				});
 				stderrParts.push(stderrDecoder.decode());
-			} catch (error) {
-				if (error instanceof microsandbox.ExecTimeoutError) {
+				if (drained.kind === "exited") exitCode = drained.exitCode;
+				else if (drained.kind === "timed_out") {
 					exitCode = 124;
-					stderrParts.push(`exec timed out: ${formatError(error)}`);
-				} else {
-					exitCode = 1;
-					stderrParts.push(`exec failed: ${formatError(error)}`);
+					stderrParts.push(drained.reason === "inactivity" ? `exec stream timed out: no events for ${EXEC_INACTIVITY_TIMEOUT_MS / 6e4} minutes; abandoning the run and tearing the sandbox down\n` : `exec stream timed out: run exceeded the ${EXEC_MAX_DURATION_MS / 6e4}-minute ceiling; abandoning the run and tearing the sandbox down\n`);
 				}
+			} catch (error) {
+				exitCode = 1;
+				stderrParts.push(`exec failed: ${formatError(error)}`);
 			}
 		} catch (error) {
 			exitCode = 1;
@@ -31335,6 +31386,53 @@ function formatCombinedRepairError(repo, branch, tree) {
 		"Operator must inspect and choose the order manually."
 	].join("\n");
 }
+const RESERVED_OUTPUT_SUBDIRS = new Set(["types", "views"]);
+const OUTPUT_DIR_RELATIVE = "output";
+const CURSORS_DIR_RELATIVE = ".engine/cursors";
+async function planRootReset(rootDir) {
+	const cursorFiles = (await readDirNames(cursorsDirPath(rootDir))).filter((name) => name.endsWith(".json"));
+	return {
+		contentPaths: (await readDirNames(path.join(rootDir, OUTPUT_DIR_RELATIVE))).filter((name) => !RESERVED_OUTPUT_SUBDIRS.has(name)).map((name) => path.join(OUTPUT_DIR_RELATIVE, name)).sort(),
+		cursorPaths: cursorFiles.map((name) => path.join(CURSORS_DIR_RELATIVE, name)).sort()
+	};
+}
+async function runRootReset(repo, options = {}) {
+	const preflight = await runRootPreflight(repo);
+	if (!preflight.ready && !options.force) throw new Error(formatNotReadyError(repo, preflight.issues));
+	const plan = await planRootReset(repo.rootDir);
+	for (const relativePath of [...plan.cursorPaths, ...plan.contentPaths]) await rm(path.join(repo.rootDir, relativePath), {
+		force: true,
+		recursive: true
+	});
+	if ((await inspectWorkingTree(repo)).clean) return { kind: "no_op" };
+	const { sha } = await commitRootReset(repo, { resetId: v7() });
+	await pushToOrigin(repo);
+	return {
+		commit: {
+			pushed: repo.mode === "remote",
+			sha
+		},
+		kind: "reset",
+		removedContent: plan.contentPaths,
+		removedCursors: plan.cursorPaths
+	};
+}
+async function readDirNames(dir) {
+	try {
+		return await readdir$1(dir);
+	} catch (error) {
+		if (isNodeError(error) && error.code === "ENOENT") return [];
+		throw error;
+	}
+}
+function formatNotReadyError(repo, issues) {
+	const list = issues.map((issue) => `  - ${issue.message}`).join("\n");
+	return [
+		`RootReset refuses to act: engine root '${repo.rootDir}' is not ready.`,
+		list,
+		"Commit your authored config (or run 'ctxe repair'), or pass --force to reset anyway."
+	].join("\n");
+}
 const SOURCE_UPDATED_AT_COLUMN = "_ctx_source_updated_at";
 async function captureWatermark(input) {
 	const sql = src_default(input.databaseUrl);
@@ -31510,6 +31608,29 @@ async function runRepairCommand(repo) {
 	process.stdout.write(`${formatJsonOutput(result)}\n`);
 }
 
+//#endregion
+//#region commands/reset.ts
+async function runResetCommand(input) {
+	const { repo, yes, force } = input;
+	if (!yes) {
+		const preflight = await runRootPreflight(repo);
+		const plan = await planRootReset(repo.rootDir);
+		process.stdout.write(`${formatJsonOutput({
+			dryRun: true,
+			hint: "pass --yes to execute (commits the wipe), then 'ctxe backfill <name>' to rebuild",
+			issues: preflight.issues,
+			ready: preflight.ready,
+			wouldRemove: {
+				content: plan.contentPaths,
+				cursors: plan.cursorPaths
+			}
+		})}\n`);
+		return;
+	}
+	const result = await runRootReset(repo, { force });
+	process.stdout.write(`${formatJsonOutput(result)}\n`);
+}
+
 //#endregion
 //#region commands/run.ts
 async function runRunCommand(input) {
@@ -31612,6 +31733,13 @@ function createProgram() {
 	program.command("repair").description("Explicit out-of-band root repair: safe fast-forward when clean and stale, or dirty-root rollback that preserves .engine/runs/**. Refuses local-ahead state, divergence, and the combined stale-plus-dirty case.").action(async function() {
 		await runRepairCommand(resolveRepoContext(this));
 	});
+	program.command("reset").option("--yes", "Execute the reset (delete cursors + wipe synthesized content, then commit). Without it, prints the plan and exits without mutating.").option("--force", "Reset even when the root is not preflight-ready (e.g. a dirty working tree). Use with care; normally you commit authored config or run 'ctxe repair' first.").description("Reset the whole workspace to a clean pre-synthesis state so it can be rebuilt from scratch: delete every synthesizer cursor (the next run bootstraps from engine.json's oldestConsideredPoint) and wipe all synthesized content under output/ except the authored types/ and views/, in one commit. Whole-workspace by design — output/ is not partitioned by synthesizer. Preserves .engine/runs/**. Default is a dry run; pass --yes to execute, then rebuild with 'ctxe backfill <synthesizer>' or 'ctxe daemon start'.").action(async function(options) {
+		await runResetCommand({
+			force: options.force ?? false,
+			repo: resolveRepoContext(this),
+			yes: options.yes ?? false
+		});
+	});
 	program.command("run").argument("<synthesizer>", "Synthesizer name").option("--database-url <url>", "Postgres URL of the ContextBase database the synthesizer reads from. Falls back to CTXB_DATABASE_URL.").description("Run a single synthesizer once. Exits non-zero on a failed or timed-out run.").action(async function(synthesizerName, options) {
 		await runRunCommand({
 			databaseUrl: options.databaseUrl,
@@ -31655,4 +31783,4 @@ runCli().catch((error) => {
 //#endregion
 export { createProgram, resolveRepoContext, resolveRuntimePaths, runCli };
 //# sourceMappingURL=cli.mjs.map
-//# debugId=b91f2a1b-d2ef-5d42-a3e9-b2e7ffe81cc4
+//# debugId=59a42f57-145c-5f77-afb2-f1f76467783d