@hexclave/shared-backend 1.0.36 → 1.0.37

package/dist/esm/index.js

@@ -1,448 +1,5 @@
-import path from "path";
-import { existsSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "fs";
-import { showOnboardingHexclaveConfigValue } from "@hexclave/shared/dist/config-authoring";
-import { detectImportPackageFromDir, parseHexclaveConfigFileContent, renderConfigFileContent } from "@hexclave/shared/dist/config-rendering";
-import { isValidConfig, normalize, override } from "@hexclave/shared/dist/config/format";
-import { captureError } from "@hexclave/shared/dist/utils/errors";
-import { createHash } from "crypto";
-import { createJiti } from "jiti";
-import { ClaudeAgentFailureError, ClaudeAgentTimeoutError, getToolWriteTargetPath, isPathInsideDir, runHeadlessClaudeAgent } from "./config-agent.js";
+export * from "./config-file.js"
 
-//#region src/index.ts
-const jiti = createJiti(import.meta.url, { moduleCache: false });
-const LOG_PREFIX = "[Stack config updater]";
-const DEFAULT_AGENT_TIMEOUT_MS = 12e4;
-const CONFIG_UPDATE_LOG_PATH_LIMIT = 40;
-const AGENT_OUTPUT_LOG_MAX_LENGTH = 2e4;
-function formatConfigUpdaterErrorForLog(error) {
-	if (error instanceof Error) return {
-		errorName: error.name,
-		errorMessage: error.message,
-		errorStack: error.stack
-	};
-	return { errorMessage: String(error) };
-}
-function configUpdatePathDetailsForLog(changes) {
-	const paths = changes.map(({ path: configPath }) => configPath).sort();
-	return {
-		configUpdatePathCount: paths.length,
-		configUpdatePaths: paths.slice(0, CONFIG_UPDATE_LOG_PATH_LIMIT),
-		configUpdatePathsTruncated: paths.length > CONFIG_UPDATE_LOG_PATH_LIMIT
-	};
-}
-function appendBoundedAgentOutput(current, chunk) {
-	const next = `${current}${chunk}`;
-	if (next.length <= AGENT_OUTPUT_LOG_MAX_LENGTH) return next;
-	return next.slice(next.length - AGENT_OUTPUT_LOG_MAX_LENGTH);
-}
-function stringifyAgentMessageForLog(message) {
-	try {
-		return `${JSON.stringify(message)}\n`;
-	} catch {
-		return `${String(message)}\n`;
-	}
-}
-function agentOutputDetailsForLog(agentStdout, agentStderr) {
-	return {
-		agentStdout,
-		agentStdoutTruncated: agentStdout.length >= AGENT_OUTPUT_LOG_MAX_LENGTH,
-		agentStderr,
-		agentStderrTruncated: agentStderr.length >= AGENT_OUTPUT_LOG_MAX_LENGTH
-	};
-}
-function isConfigModule(value) {
-	return value !== null && typeof value === "object";
-}
-function sha256String(value) {
-	return createHash("sha256").update(value).digest("hex");
-}
-function resolveConfigFilePath(inputPath) {
-	const resolved = path.resolve(inputPath);
-	if (/\.(ts|js|mjs|cjs)$/i.test(resolved)) return resolved;
-	const hexclaveCandidate = path.join(resolved, "hexclave.config.ts");
-	const legacyCandidate = path.join(resolved, "stack.config.ts");
-	if (existsSync(hexclaveCandidate)) return hexclaveCandidate;
-	if (existsSync(legacyCandidate)) return legacyCandidate;
-	return hexclaveCandidate;
-}
-function ensureConfigFileExists(configFilePath) {
-	if (existsSync(configFilePath)) return;
-	mkdirSync(path.dirname(configFilePath), { recursive: true });
-	renderConfigObjectToFile(configFilePath, {});
-}
-async function readConfigObject(configFilePath) {
-	return (await readConfigFile(configFilePath)).config;
-}
-async function readConfigFile(configFilePath) {
-	ensureConfigFileExists(configFilePath);
-	if (readFileSync(configFilePath, "utf-8").trim() === "") return {
-		config: {},
-		showOnboarding: false
-	};
-	let configModule;
-	try {
-		configModule = await jiti.import(configFilePath);
-	} catch (error) {
-		captureError("shared-backend/readConfigFile", error);
-		throw new Error(`Failed to load config file ${configFilePath}.`);
-	}
-	if (!isConfigModule(configModule)) throw new Error(`Invalid config in ${configFilePath}. The file must export a plain \`config\` object or "show-onboarding".`);
-	const config = configModule.config;
-	if (config === showOnboardingHexclaveConfigValue) return {
-		config: {},
-		showOnboarding: true
-	};
-	if (!isValidConfig(config)) throw new Error(`Invalid config in ${configFilePath}.`);
-	return {
-		config,
-		showOnboarding: false
-	};
-}
-function renderConfigObjectToString(configFilePath, config) {
-	return renderConfigFileContent(config, detectImportPackageFromDir(path.dirname(configFilePath)));
-}
-function writeFileAtomic(configFilePath, content) {
-	const dir = path.dirname(configFilePath);
-	mkdirSync(dir, { recursive: true });
-	const tempPath = path.join(dir, `.stack.config.${Math.random().toString(36).slice(2)}.tmp`);
-	writeFileSync(tempPath, content, "utf-8");
-	try {
-		renameSync(tempPath, configFilePath);
-	} catch (error) {
-		try {
-			rmSync(tempPath);
-		} catch {}
-		throw error;
-	}
-}
-function renderConfigObjectToFile(configFilePath, config) {
-	writeFileAtomic(configFilePath, renderConfigObjectToString(configFilePath, config));
-}
-async function updateConfigObject(configFilePath, configUpdate) {
-	const startedAtMs = performance.now();
-	ensureConfigFileExists(configFilePath);
-	const changes = flattenConfigUpdate(configUpdate);
-	if (changes.length === 0) {
-		console.log(`${LOG_PREFIX} Skipping config update because it contains no changes`, { configFilePath });
-		return;
-	}
-	const updateLogDetails = {
-		configFilePath,
-		...configUpdatePathDetailsForLog(changes)
-	};
-	console.log(`${LOG_PREFIX} Starting config file update`, updateLogDetails);
-	const content = readFileSync(configFilePath, "utf-8");
-	const staticConfig = tryParseStaticConfigFileContent(content, configFilePath);
-	if (staticConfig != null && isValidConfig(staticConfig)) {
-		console.log(`${LOG_PREFIX} Applying config update with static config rewrite`, updateLogDetails);
-		const merged = override(staticConfig, configUpdate);
-		if (!isValidConfig(merged)) throw new Error(`${LOG_PREFIX} Merged config is invalid after applying update to ${configFilePath}`);
-		renderConfigObjectToFile(configFilePath, merged);
-		console.log(`${LOG_PREFIX} Finished config update with static config rewrite`, {
-			...updateLogDetails,
-			elapsedMs: Math.round(performance.now() - startedAtMs)
-		});
-		return;
-	}
-	console.log(`${LOG_PREFIX} Applying config update with agent-assisted rewrite`, {
-		...updateLogDetails,
-		configDirectory: path.dirname(configFilePath)
-	});
-	const baselineConfig = await tryReadConfigForValidation(configFilePath);
-	const { snapshots, seen } = snapshotConfigFiles(configFilePath, content);
-	try {
-		await runConfigUpdateAgent({
-			prompt: buildConfigUpdatePrompt(path.basename(configFilePath), configUpdate, baselineConfig),
-			cwd: path.dirname(configFilePath),
-			onFileWillChange: (filePath) => captureSnapshotIfAbsent(snapshots, filePath, seen)
-		});
-		await validateAgentUpdate(configFilePath, baselineConfig, configUpdate, snapshots);
-	} catch (error) {
-		console.warn(`${LOG_PREFIX} Config update failed; restoring files from snapshots`, {
-			...updateLogDetails,
-			snapshotCount: snapshots.length,
-			elapsedMs: Math.round(performance.now() - startedAtMs),
-			...formatConfigUpdaterErrorForLog(error)
-		});
-		try {
-			restoreConfigFiles(snapshots);
-			console.warn(`${LOG_PREFIX} Restored files after failed config update`, {
-				...updateLogDetails,
-				snapshotCount: snapshots.length
-			});
-		} catch (restoreError) {
-			console.error(`${LOG_PREFIX} Failed to fully roll back config files after a failed update of ${configFilePath}; some files may be left in a partially-restored state`, {
-				configFilePath,
-				...formatConfigUpdaterErrorForLog(restoreError)
-			});
-		}
-		throw error;
-	}
-	console.log(`${LOG_PREFIX} Finished config update with agent-assisted rewrite`, {
-		...updateLogDetails,
-		elapsedMs: Math.round(performance.now() - startedAtMs),
-		snapshotCount: snapshots.length
-	});
-}
-async function replaceConfigObject(configFilePath, config) {
-	renderConfigObjectToFile(configFilePath, config);
-}
-async function runConfigUpdateAgent(options) {
-	const timeoutMs = parseAgentTimeoutMs();
-	const deniedOutOfBoundsWrites = /* @__PURE__ */ new Set();
-	const startedAtMs = performance.now();
-	let agentStdout = "";
-	let agentStderr = "";
-	console.log(`${LOG_PREFIX} Starting config update agent`, {
-		cwd: options.cwd,
-		timeoutMs
-	});
-	try {
-		await runHeadlessClaudeAgent({
-			prompt: options.prompt,
-			cwd: options.cwd,
-			allowedTools: [
-				"Read",
-				"Write",
-				"Edit",
-				"Glob",
-				"Grep"
-			],
-			strictIsolation: true,
-			timeoutMs,
-			stderr: (data) => {
-				agentStderr = appendBoundedAgentOutput(agentStderr, data);
-				console.warn(`${LOG_PREFIX} [agent] ${data}`);
-			},
-			onMessage: (message) => {
-				agentStdout = appendBoundedAgentOutput(agentStdout, stringifyAgentMessageForLog(message));
-			},
-			onPreToolUse: (input) => {
-				const target = getToolWriteTargetPath(input.tool_name, input.tool_input, options.cwd);
-				if (target == null) return { continue: true };
-				if (!isPathInsideDir(options.cwd, target)) {
-					deniedOutOfBoundsWrites.add(target);
-					return { hookSpecificOutput: {
-						hookEventName: "PreToolUse",
-						permissionDecision: "deny",
-						permissionDecisionReason: `Refusing to modify ${target}: config updates may only change files inside the config directory.`
-					} };
-				}
-				options.onFileWillChange?.(target);
-				return { continue: true };
-			}
-		});
-	} catch (error) {
-		if (error instanceof ClaudeAgentTimeoutError) {
-			console.warn(`${LOG_PREFIX} Config update agent timed out`, {
-				cwd: options.cwd,
-				timeoutMs,
-				elapsedMs: Math.round(performance.now() - startedAtMs),
-				...formatConfigUpdaterErrorForLog(error),
-				...agentOutputDetailsForLog(agentStdout, agentStderr)
-			});
-			throw new Error(`Config update agent timed out after ${timeoutMs}ms. It was unable to apply the config changes to the file.`);
-		}
-		if (error instanceof ClaudeAgentFailureError) {
-			console.warn(`${LOG_PREFIX} Config update agent failed`, {
-				cwd: options.cwd,
-				timeoutMs,
-				elapsedMs: Math.round(performance.now() - startedAtMs),
-				...formatConfigUpdaterErrorForLog(error),
-				...agentOutputDetailsForLog(agentStdout, agentStderr)
-			});
-			throw new Error(`${error.message} It was unable to apply the config changes to the file.`);
-		}
-		console.warn(`${LOG_PREFIX} Config update agent failed unexpectedly`, {
-			cwd: options.cwd,
-			timeoutMs,
-			elapsedMs: Math.round(performance.now() - startedAtMs),
-			...formatConfigUpdaterErrorForLog(error),
-			...agentOutputDetailsForLog(agentStdout, agentStderr)
-		});
-		throw error;
-	}
-	console.log(`${LOG_PREFIX} Finished config update agent`, {
-		cwd: options.cwd,
-		timeoutMs,
-		elapsedMs: Math.round(performance.now() - startedAtMs),
-		deniedOutOfBoundsWriteCount: deniedOutOfBoundsWrites.size
-	});
-	if (deniedOutOfBoundsWrites.size > 0) {
-		console.warn(`${LOG_PREFIX} Config update agent attempted out-of-bounds writes`, {
-			cwd: options.cwd,
-			deniedOutOfBoundsWriteCount: deniedOutOfBoundsWrites.size,
-			deniedOutOfBoundsWrites: [...deniedOutOfBoundsWrites]
-		});
-		throw new Error(`Config update agent tried to modify ${deniedOutOfBoundsWrites.size} file(s) outside the config directory, which is not allowed: ${[...deniedOutOfBoundsWrites].join(", ")}. The config was not updated.`);
-	}
-}
-function parseAgentTimeoutMs() {
-	const raw = process.env.STACK_CONFIG_UPDATE_AGENT_TIMEOUT_MS;
-	if (raw == null || raw.trim() === "") return DEFAULT_AGENT_TIMEOUT_MS;
-	const parsed = Number(raw);
-	if (!Number.isFinite(parsed) || parsed <= 0) throw new Error(`Invalid STACK_CONFIG_UPDATE_AGENT_TIMEOUT_MS: ${JSON.stringify(raw)}. Expected a positive number of milliseconds.`);
-	return parsed;
-}
-function captureSnapshotIfAbsent(snapshots, filePath, seen) {
-	const resolved = path.resolve(filePath);
-	if (seen.has(resolved)) return;
-	seen.add(resolved);
-	snapshots.push({
-		path: resolved,
-		content: existsSync(resolved) ? readFileSync(resolved, "utf-8") : null
-	});
-}
-function snapshotConfigFiles(configFilePath, configContent) {
-	const dir = path.dirname(configFilePath);
-	const resolvedConfig = path.resolve(configFilePath);
-	const snapshots = [{
-		path: resolvedConfig,
-		content: configContent
-	}];
-	const seen = new Set([resolvedConfig]);
-	for (const specifier of getRelativeImportSpecifiers(configContent)) {
-		const resolved = path.resolve(dir, specifier);
-		if (!isPathInsideDir(dir, resolved)) continue;
-		captureSnapshotIfAbsent(snapshots, resolved, seen);
-	}
-	return {
-		snapshots,
-		seen
-	};
-}
-function restoreConfigFiles(snapshots) {
-	const failures = [];
-	for (const { path: filePath, content } of snapshots) try {
-		if (content === null) {
-			if (existsSync(filePath)) rmSync(filePath);
-		} else writeFileSync(filePath, content, "utf-8");
-	} catch (error) {
-		failures.push(`${filePath}: ${error instanceof Error ? error.message : String(error)}`);
-	}
-	if (failures.length > 0) throw new Error(`Failed to restore ${failures.length} file(s) during rollback: ${failures.join("; ")}`);
-}
-async function tryReadConfigForValidation(configFilePath) {
-	try {
-		return (await readConfigFile(configFilePath)).config;
-	} catch (error) {
-		console.warn(`${LOG_PREFIX} Could not evaluate config for validation baseline; will fall back to a structural check`, {
-			configFilePath,
-			error: error instanceof Error ? error.message : String(error)
-		});
-		return null;
-	}
-}
-async function validateAgentUpdate(configFilePath, baselineConfig, configUpdate, snapshots) {
-	if (baselineConfig != null) {
-		const target = canonicalizeConfig(override(baselineConfig, configUpdate));
-		if (!configsEqual(canonicalizeConfig((await readConfigFile(configFilePath)).config), target)) throw new Error(`Config update validation failed for ${configFilePath}: the updated file does not evaluate to the expected configuration.`);
-		return;
-	}
-	if (flattenConfigUpdate(configUpdate).length > 0 && !snapshotsChangedOnDisk(snapshots)) console.warn(`${LOG_PREFIX} Agent did not modify any file for ${configFilePath}; assuming values are already up to date.`);
-	if (!configFileExportsConfig(readFileSync(configFilePath, "utf-8"), configFilePath)) throw new Error(`Config update validation failed for ${configFilePath}: the updated file no longer exports a valid \`config\`.`);
-}
-function tryParseStaticConfigFileContent(content, configFilePath) {
-	try {
-		const parsed = parseHexclaveConfigFileContent(content, configFilePath);
-		return isValidConfig(parsed) ? parsed : null;
-	} catch {
-		return null;
-	}
-}
-function configFileExportsConfig(content, configFilePath) {
-	try {
-		parseHexclaveConfigFileContent(content, configFilePath);
-		return true;
-	} catch {
-		return /\bexport\s+const\s+config\b/.test(content);
-	}
-}
-function getRelativeImportSpecifiers(content) {
-	const specifiers = [];
-	const importPattern = /\bimport\b(?:[^'"]*?\bfrom\s*)?["'](\.{1,2}\/[^"']+)["']/g;
-	let match;
-	while ((match = importPattern.exec(content)) !== null) specifiers.push(match[1]);
-	return specifiers;
-}
-function snapshotsChangedOnDisk(snapshots) {
-	return snapshots.some(({ path: filePath, content }) => {
-		return (existsSync(filePath) ? readFileSync(filePath, "utf-8") : null) !== content;
-	});
-}
-function flattenConfigUpdate(update) {
-	const changes = [];
-	const walk = (prefix, obj) => {
-		for (const [key, value] of Object.entries(obj)) {
-			const fullPath = prefix === "" ? key : `${prefix}.${key}`;
-			if (value === void 0) continue;
-			if (value !== null && typeof value === "object" && !Array.isArray(value) && Object.keys(value).length > 0) walk(fullPath, value);
-			else changes.push({
-				path: fullPath,
-				value
-			});
-		}
-	};
-	walk("", update);
-	return changes;
-}
-function buildConfigUpdatePrompt(configFileName, configUpdate, baselineConfig) {
-	const changeLines = flattenConfigUpdate(configUpdate).map(({ path: configPath, value }) => {
-		return `- ${JSON.stringify(configPath)}: set to ${JSON.stringify(value)}`;
-	}).join("\n");
-	const expectedConfig = baselineConfig == null ? null : canonicalizeConfig(override(baselineConfig, configUpdate));
-	const expectedConfigSection = expectedConfig == null ? "" : `
-After the edit, evaluating the exported \`config\` must produce this exact JSON value:
+export * from "./config-updater.js"
 
-${JSON.stringify(expectedConfig, null, 2)}
-`;
-	return `You are editing a Hexclave / Stack Auth configuration file in place. Apply a set of configuration changes WITHOUT changing how the file is written.
-
-Config file: ${JSON.stringify(configFileName)} (in the current working directory).
-
-The file exports a \`config\` object (it may be wrapped in a helper such as \`defineStackConfig(...)\`). Some config values may be sourced from other files via imports, for example:
-
-    import welcomeEmail from "./welcome-email.tsx" with { type: "text" };
-    export const config = { emails: { templates: { welcome: welcomeEmail } } };
-
-Apply EXACTLY these changes. Paths use dot notation, so \`a.b.c\` refers to \`config.a.b.c\`:
-
-${changeLines}
-${expectedConfigSection}
-
-Rules:
-- Change ONLY the config paths listed above. Leave every other part of the file byte-for-byte unchanged: imports, comments, formatting, helper wrappers, and any config fields not listed.
-- If a listed path's value is currently provided by an imported external file (like the \`import ... with { type: "text" }\` example above), DO NOT inline the new value into the config file. Instead, overwrite that external file with the new value and keep the import statement intact.
-- If a listed path's value is a plain inline literal, edit it inline.
-- Keep the file valid: it must still export a \`config\` that, once evaluated, reflects the new values exactly.
-- Do not run any shell commands and do not create files other than what is required to apply these changes.`;
-}
-function canonicalizeConfig(config) {
-	const droppedKeys = [];
-	const normalized = normalize(config, {
-		onDotIntoNonObject: "ignore",
-		onDotIntoNull: "empty-object",
-		droppedKeys
-	});
-	if (droppedKeys.length > 0) throw new Error(`Config update has conflicting keys that would be dropped during normalization: ${droppedKeys.map((key) => JSON.stringify(key)).join(", ")}`);
-	return normalized;
-}
-function configsEqual(a, b) {
-	if (a === b) return true;
-	if (a === null || b === null) return a === b;
-	if (Array.isArray(a) || Array.isArray(b)) {
-		if (!Array.isArray(a) || !Array.isArray(b) || a.length !== b.length) return false;
-		return a.every((value, index) => configsEqual(value, b[index]));
-	}
-	if (typeof a === "object" && typeof b === "object") {
-		const aEntries = Object.entries(a);
-		const bMap = new Map(Object.entries(b));
-		if (aEntries.length !== bMap.size) return false;
-		return aEntries.every(([key, value]) => bMap.has(key) && configsEqual(value, bMap.get(key)));
-	}
-	return false;
-}
-
-//#endregion
-export { ensureConfigFileExists, readConfigFile, readConfigObject, replaceConfigObject, resolveConfigFilePath, sha256String, updateConfigObject };
-//# sourceMappingURL=index.js.map
+export {  };

package/dist/index.d.ts

@@ -1,16 +1,3 @@
-import { Config } from "@hexclave/shared/dist/config/format";
-
-//#region src/index.d.ts
-declare function sha256String(value: string): string;
-declare function resolveConfigFilePath(inputPath: string): string;
-declare function ensureConfigFileExists(configFilePath: string): void;
-declare function readConfigObject(configFilePath: string): Promise<Config>;
-declare function readConfigFile(configFilePath: string): Promise<{
-  config: Config;
-  showOnboarding: boolean;
-}>;
-declare function updateConfigObject(configFilePath: string, configUpdate: Config): Promise<void>;
-declare function replaceConfigObject(configFilePath: string, config: Config): Promise<void>;
-//#endregion
-export { ensureConfigFileExists, readConfigFile, readConfigObject, replaceConfigObject, resolveConfigFilePath, sha256String, updateConfigObject };
-//# sourceMappingURL=index.d.ts.map
+import { ensureConfigFileExists, readConfigFile, readConfigObject, replaceConfigObject, resolveConfigFilePath, sha256String } from "./config-file.js";
+import { updateConfigObject } from "./config-updater.js";
+export { ensureConfigFileExists, readConfigFile, readConfigObject, replaceConfigObject, resolveConfigFilePath, sha256String, updateConfigObject };