@zenbujs/core 0.0.1

package/dist/loaders/zenbu.mjs

@@ -0,0 +1,267 @@
+import { createRequire } from "node:module";
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+//#region src/loaders/zenbu.ts
+const verbose = process.env.ZENBU_VERBOSE === "1";
+const { subscribe } = createRequire(import.meta.url)("@parcel/watcher");
+let registerWatcherClosable = () => {};
+try {
+	const pause = await import("../pause-DvAUNmKn.mjs");
+	registerWatcherClosable = typeof pause.registerWatcherClosable === "function" ? pause.registerWatcherClosable : registerWatcherClosable;
+} catch {}
+const loaderName = "zenbu-loader";
+let tracePort = null;
+const stats = {
+	resolveCount: 0,
+	resolveMs: 0,
+	loadCount: 0,
+	loadMs: 0
+};
+const barrels = /* @__PURE__ */ new Map();
+const dirWatchers = /* @__PURE__ */ new Map();
+function initialize(data) {
+	if (!data?.tracePort) return;
+	tracePort = data.tracePort;
+	tracePort.on("message", (msg) => {
+		if (msg !== "flush") return;
+		try {
+			tracePort?.postMessage({
+				name: loaderName,
+				...stats
+			});
+		} catch {}
+		stats.resolveCount = 0;
+		stats.resolveMs = 0;
+		stats.loadCount = 0;
+		stats.loadMs = 0;
+	});
+	tracePort.unref?.();
+}
+function parseJsonc(str) {
+	let result = "";
+	let i = 0;
+	while (i < str.length) if (str[i] === "\"") {
+		let j = i + 1;
+		while (j < str.length) if (str[j] === "\\") j += 2;
+		else if (str[j] === "\"") {
+			j++;
+			break;
+		} else j++;
+		result += str.slice(i, j);
+		i = j;
+	} else if (str[i] === "/" && str[i + 1] === "/") {
+		i += 2;
+		while (i < str.length && str[i] !== "\n") i++;
+	} else if (str[i] === "/" && str[i + 1] === "*") {
+		i += 2;
+		while (i < str.length && !(str[i] === "*" && str[i + 1] === "/")) i++;
+		i += 2;
+	} else {
+		result += str[i];
+		i++;
+	}
+	return JSON.parse(result.replace(/,\s*([\]}])/g, "$1"));
+}
+function globRegex(filePattern) {
+	return new RegExp(`^${filePattern.replace(/\./g, "\\.").replace(/\*/g, ".*")}$`);
+}
+function expandGlob(pattern) {
+	const dir = path.dirname(pattern);
+	const regex = globRegex(path.basename(pattern));
+	if (!fs.existsSync(dir)) return [];
+	return fs.readdirSync(dir).filter((file) => regex.test(file)).map((file) => path.resolve(dir, file));
+}
+function snapshotDir(dir, regex) {
+	if (!fs.existsSync(dir)) return /* @__PURE__ */ new Set();
+	try {
+		return new Set(fs.readdirSync(dir).filter((file) => regex.test(file)));
+	} catch {
+		return /* @__PURE__ */ new Set();
+	}
+}
+function handleDirEvent(dir, filename) {
+	for (const entry of barrels.values()) for (const glob of entry.globs) {
+		if (glob.dir !== dir) continue;
+		if (!glob.regex.test(filename)) continue;
+		const nextSnapshot = snapshotDir(dir, glob.regex);
+		if (!(nextSnapshot.size !== glob.snapshot.size || [...nextSnapshot].some((file) => !glob.snapshot.has(file)))) continue;
+		glob.snapshot = nextSnapshot;
+		try {
+			entry.hot?.invalidate?.();
+			if (verbose) console.log(`[zenbu-loader] invalidated barrel (${filename} added/removed in ${dir})`);
+		} catch (err) {
+			console.error("[zenbu-loader] invalidate failed:", err);
+		}
+		break;
+	}
+}
+function ensureDirWatcher(dir) {
+	if (dirWatchers.has(dir)) return;
+	if (!fs.existsSync(dir)) return;
+	let subscription = null;
+	let closed = false;
+	subscribe(dir, (err, events) => {
+		if (err) return;
+		for (const event of events) {
+			if (path.dirname(event.path) !== dir) continue;
+			handleDirEvent(dir, path.basename(event.path));
+		}
+	}).then((sub) => {
+		if (closed) sub.unsubscribe().catch(() => {});
+		else subscription = sub;
+	}).catch((err) => {
+		console.error(`[zenbu-loader] subscribe failed for ${dir}:`, err);
+	});
+	const closable = { close: () => {
+		closed = true;
+		if (subscription) return subscription.unsubscribe().catch(() => {});
+	} };
+	registerWatcherClosable(closable);
+	dirWatchers.set(dir, closable);
+}
+function buildSource(imports) {
+	return imports.map((specifier) => `import ${JSON.stringify(specifier)}\n`).join("");
+}
+function readPluginList(configPath) {
+	const config = parseJsonc(fs.readFileSync(configPath, "utf8"));
+	if (!config || typeof config !== "object" || !Array.isArray(config.plugins)) return [];
+	return Array.from(new Set(config.plugins.filter((plugin) => typeof plugin === "string")));
+}
+function buildPluginRoot(configPath) {
+	return {
+		source: `${buildSource(readPluginList(configPath).map((manifestPath) => `zenbu:barrel?manifest=${encodeURIComponent(path.resolve(manifestPath))}`))}import.meta.hot?.accept()\n`,
+		watchPaths: new Set([configPath])
+	};
+}
+function buildBarrel(manifestPath) {
+	const manifest = parseJsonc(fs.readFileSync(manifestPath, "utf8"));
+	const baseDir = path.dirname(manifestPath);
+	const entries = manifest && typeof manifest === "object" && Array.isArray(manifest.services) ? manifest.services.filter((entry) => typeof entry === "string") : [];
+	const imports = [];
+	const watchPaths = new Set([manifestPath]);
+	const globs = [];
+	for (const entry of entries) {
+		const resolved = path.resolve(baseDir, entry);
+		if (resolved.includes("*")) {
+			const dir = path.dirname(resolved);
+			const regex = globRegex(path.basename(resolved));
+			watchPaths.add(dir);
+			globs.push({
+				dir,
+				regex,
+				snapshot: snapshotDir(dir, regex)
+			});
+			for (const file of expandGlob(resolved)) imports.push(pathToFileURL(file).href);
+		} else if (resolved.endsWith(".json") || resolved.endsWith(".jsonc")) imports.push(`zenbu:barrel?manifest=${encodeURIComponent(resolved)}`);
+		else imports.push(pathToFileURL(resolved).href);
+	}
+	return {
+		source: `${buildSource(imports)}import.meta.hot?.accept()\n`,
+		watchPaths,
+		globs
+	};
+}
+const CORE_PACKAGE_ROOT_FOR_LOADER = (() => {
+	const here = path.dirname(fileURLToPath(import.meta.url));
+	let dir = path.resolve(here, "..", "..");
+	while (dir !== path.dirname(dir)) {
+		const pkg = path.join(dir, "package.json");
+		if (fs.existsSync(pkg)) try {
+			if (JSON.parse(fs.readFileSync(pkg, "utf8")).name === "@zenbujs/core") return dir;
+		} catch {}
+		dir = path.dirname(dir);
+	}
+	return path.resolve(here, "..", "..");
+})();
+let coreExportsCache = null;
+function getCoreExports() {
+	if (coreExportsCache) return coreExportsCache;
+	try {
+		const pkgPath = path.join(CORE_PACKAGE_ROOT_FOR_LOADER, "package.json");
+		const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
+		if (pkg.name === "@zenbujs/core" && pkg.exports) {
+			coreExportsCache = pkg.exports;
+			return coreExportsCache;
+		}
+	} catch {}
+	return null;
+}
+function resolveCoreSubpath(specifier) {
+	const exports = getCoreExports();
+	if (!exports) return null;
+	const entry = exports[specifier === "@zenbujs/core" ? "." : "./" + specifier.slice(14)];
+	if (!entry) return null;
+	const file = typeof entry === "string" ? entry : entry.import ?? entry.default ?? null;
+	if (!file) return null;
+	return path.resolve(CORE_PACKAGE_ROOT_FOR_LOADER, file);
+}
+function resolve(specifier, context, nextResolve) {
+	const start = Date.now();
+	try {
+		if (specifier === "@zenbu/advice/runtime") return {
+			url: new URL("../advice-runtime.mjs", import.meta.url).href,
+			shortCircuit: true
+		};
+		if (specifier === "@zenbujs/core" || specifier.startsWith("@zenbujs/core/")) {
+			const resolved = resolveCoreSubpath(specifier);
+			if (resolved) return {
+				url: pathToFileURL(resolved).href,
+				shortCircuit: true
+			};
+		}
+		if (specifier.startsWith("zenbu:")) return {
+			url: specifier,
+			shortCircuit: true
+		};
+		return nextResolve(specifier, context);
+	} finally {
+		stats.resolveCount++;
+		stats.resolveMs += Date.now() - start;
+	}
+}
+function loadImpl(url, context, nextLoad) {
+	if (url.startsWith("zenbu:plugins?")) {
+		const params = new URL(url).searchParams;
+		const configPath = decodeURIComponent(params.get("config") ?? "");
+		const { source, watchPaths } = buildPluginRoot(configPath);
+		if (context.hot?.watch) for (const watchPath of watchPaths) context.hot.watch(pathToFileURL(watchPath));
+		if (verbose) console.log(`[zenbu-loader] generated plugin root for ${path.basename(configPath)} (${source.split("\n").filter(Boolean).length} imports, ${watchPaths.size} watches)`);
+		return {
+			format: "module",
+			source,
+			shortCircuit: true
+		};
+	}
+	if (url.startsWith("zenbu:barrel?")) {
+		const params = new URL(url).searchParams;
+		const manifestPath = decodeURIComponent(params.get("manifest") ?? "");
+		const { source, watchPaths, globs } = buildBarrel(manifestPath);
+		if (context.hot?.watch) for (const watchPath of watchPaths) context.hot.watch(pathToFileURL(watchPath));
+		if (context.hot) {
+			barrels.set(url, {
+				hot: context.hot,
+				globs
+			});
+			for (const glob of globs) ensureDirWatcher(glob.dir);
+		}
+		if (verbose) console.log(`[zenbu-loader] generated barrel for ${path.basename(manifestPath)} (${source.split("\n").filter(Boolean).length} imports, ${watchPaths.size} watches, ${globs.length} globs)`);
+		return {
+			format: "module",
+			source,
+			shortCircuit: true
+		};
+	}
+	return nextLoad(url, context);
+}
+function load(url, context, nextLoad) {
+	const start = Date.now();
+	try {
+		return loadImpl(url, context, nextLoad);
+	} finally {
+		stats.loadCount++;
+		stats.loadMs += Date.now() - start;
+	}
+}
+//#endregion
+export { initialize, load, resolve };

package/dist/log-CyKv8hQg.mjs

@@ -0,0 +1,20 @@
+//#region src/shared/log.ts
+const verbose = process.env.ZENBU_VERBOSE === "1";
+function createLogger(tag) {
+	const prefix = `[${tag}]`;
+	function log(...args) {
+		console.log(prefix, ...args);
+	}
+	log.verbose = (...args) => {
+		if (verbose) console.log(prefix, ...args);
+	};
+	log.warn = (...args) => {
+		console.warn(prefix, ...args);
+	};
+	log.error = (...args) => {
+		console.error(prefix, ...args);
+	};
+	return log;
+}
+//#endregion
+export { createLogger as t };

package/dist/mirror-sync-CodOnwkD.mjs

@@ -0,0 +1,332 @@
+import { n as resolveBuildConfig } from "./build-config-pbv0w4oN.mjs";
+import { createRequire } from "node:module";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+import crypto from "node:crypto";
+import fsp from "node:fs/promises";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+//#region src/cli/lib/load-build-config.ts
+const localRequire = createRequire(import.meta.url);
+const CONFIG_NAMES = [
+	"zenbu.build.ts",
+	"zenbu.build.mts",
+	"zenbu.build.js",
+	"zenbu.build.mjs"
+];
+function findBuildConfig(projectDir) {
+	for (const name of CONFIG_NAMES) {
+		const candidate = path.join(projectDir, name);
+		if (fs.existsSync(candidate)) return candidate;
+	}
+	throw new Error(`No zenbu.build config found at ${projectDir}. Expected one of: ${CONFIG_NAMES.join(", ")}`);
+}
+let tsxRegistered = null;
+function ensureTsxRegistered() {
+	if (tsxRegistered) return tsxRegistered;
+	tsxRegistered = (async () => {
+		try {
+			const tsxApi = localRequire("tsx/esm/api");
+			if (typeof tsxApi.register === "function") tsxApi.register();
+		} catch {}
+	})();
+	return tsxRegistered;
+}
+async function loadBuildConfig(configPath) {
+	await ensureTsxRegistered();
+	const mod = await import(pathToFileURL(path.resolve(configPath)).href);
+	const config = mod.default ?? mod;
+	if (!config || !Array.isArray(config.include)) throw new Error(`${path.basename(configPath)} must export a config object (via defineBuildConfig) with an 'include' array.`);
+	return resolveBuildConfig(config);
+}
+//#endregion
+//#region src/cli/lib/mirror-sync.ts
+const execFile$1 = promisify(execFile);
+const SYNCED_FROM_RE = /\[synced from ([0-9a-f]{7,40})\]/;
+async function git(cwd, args) {
+	const { stdout } = await execFile$1("git", args, {
+		cwd,
+		env: {
+			...process.env,
+			GIT_TERMINAL_PROMPT: "0"
+		},
+		maxBuffer: 64 * 1024 * 1024
+	});
+	return stdout;
+}
+async function gitTry(cwd, args) {
+	try {
+		return await git(cwd, args);
+	} catch {
+		return null;
+	}
+}
+async function shallowCloneMirror(mirrorUrl, branch) {
+	const dir = await fsp.mkdtemp(path.join(os.tmpdir(), "zenbu-mirror-"));
+	try {
+		await git(dir, [
+			"clone",
+			"--depth",
+			"1",
+			"--branch",
+			branch,
+			mirrorUrl,
+			"."
+		]);
+		return {
+			dir,
+			isEmpty: false
+		};
+	} catch {
+		await git(dir, [
+			"init",
+			"-b",
+			branch
+		]);
+		await git(dir, [
+			"remote",
+			"add",
+			"origin",
+			mirrorUrl
+		]);
+		return {
+			dir,
+			isEmpty: true
+		};
+	}
+}
+async function readHeadSyncedFromSha(repoDir) {
+	if (!await gitTry(repoDir, ["rev-parse", "HEAD"])) return null;
+	const message = await git(repoDir, [
+		"log",
+		"-1",
+		"--format=%B"
+	]);
+	return SYNCED_FROM_RE.exec(message)?.[1] ?? null;
+}
+async function emptyTrackedTree(repoDir) {
+	const entries = await fsp.readdir(repoDir, { withFileTypes: true });
+	for (const entry of entries) {
+		if (entry.name === ".git") continue;
+		const target = path.join(repoDir, entry.name);
+		await fsp.rm(target, {
+			recursive: true,
+			force: true
+		});
+	}
+}
+async function copyTree(source, dest) {
+	const entries = await fsp.readdir(source, { withFileTypes: true });
+	for (const entry of entries) {
+		if (entry.name === ".sha") continue;
+		const src = path.join(source, entry.name);
+		const dst = path.join(dest, entry.name);
+		if (entry.isDirectory()) {
+			await fsp.mkdir(dst, { recursive: true });
+			await copyTree(src, dst);
+		} else if (entry.isSymbolicLink()) {
+			const link = await fsp.readlink(src);
+			await fsp.symlink(link, dst);
+		} else await fsp.copyFile(src, dst);
+	}
+}
+async function commitAndPush(repoDir, branch, sourceSha, options) {
+	await git(repoDir, ["add", "-A"]);
+	if (!(await git(repoDir, ["status", "--porcelain"])).trim()) return {
+		pushed: false,
+		sha: (await gitTry(repoDir, ["rev-parse", "HEAD"]))?.trim() ?? null,
+		reason: "no changes"
+	};
+	const env = {
+		...process.env,
+		GIT_TERMINAL_PROMPT: "0"
+	};
+	if (options.authorName) {
+		env.GIT_AUTHOR_NAME = options.authorName;
+		env.GIT_COMMITTER_NAME = options.authorName;
+	}
+	if (options.authorEmail) {
+		env.GIT_AUTHOR_EMAIL = options.authorEmail;
+		env.GIT_COMMITTER_EMAIL = options.authorEmail;
+	}
+	await execFile$1("git", [
+		"commit",
+		"-m",
+		`${options.commitTitle ?? `chore: sync source ${sourceSha.slice(0, 7)}`}\n\n[synced from ${sourceSha}]\n`
+	], {
+		cwd: repoDir,
+		env
+	});
+	await execFile$1("git", [
+		"push",
+		"origin",
+		`HEAD:${branch}`
+	], {
+		cwd: repoDir,
+		env
+	});
+	return {
+		pushed: true,
+		sha: (await git(repoDir, ["rev-parse", "HEAD"])).trim()
+	};
+}
+/**
+* Seed an empty mirror with the staged content. Fails if the mirror's HEAD
+* already has a `[synced from <sha>]` trailer (unless `force`).
+*/
+async function init(options) {
+	const branch = options.branch ?? "main";
+	const { dir: workDir } = await shallowCloneMirror(options.mirrorUrl, branch);
+	try {
+		const existing = await readHeadSyncedFromSha(workDir);
+		if (existing && !options.force) throw new Error(`mirror already initialized (HEAD has [synced from ${existing.slice(0, 7)}]); use \`zen publish:source push\` instead, or pass --force`);
+		await emptyTrackedTree(workDir);
+		await copyTree(options.staging, workDir);
+		const result = await commitAndPush(workDir, branch, options.sourceSha, {
+			commitTitle: options.commitTitle,
+			authorName: options.authorName,
+			authorEmail: options.authorEmail
+		});
+		if (!result.pushed) return {
+			status: "noop",
+			reason: result.reason
+		};
+		return {
+			status: "pushed",
+			mirrorSha: result.sha ?? void 0
+		};
+	} finally {
+		await fsp.rm(workDir, {
+			recursive: true,
+			force: true
+		});
+	}
+}
+/**
+* Snapshot the staging dir into a new mirror commit. Refuses if the mirror
+* has no `[synced from]` trailer. No-ops if the existing trailer's source SHA
+* already matches `sourceSha` (mirror is up to date).
+*/
+async function push(options) {
+	const branch = options.branch ?? "main";
+	const { dir: workDir, isEmpty } = await shallowCloneMirror(options.mirrorUrl, branch);
+	try {
+		if (isEmpty) throw new Error("mirror is empty; run `zen publish:source init` first");
+		const lastSynced = await readHeadSyncedFromSha(workDir);
+		if (!lastSynced) throw new Error("mirror not initialized (HEAD has no [synced from] trailer); run `zen publish:source init` first");
+		if (lastSynced === options.sourceSha) return {
+			status: "noop",
+			reason: "already up to date"
+		};
+		await emptyTrackedTree(workDir);
+		await copyTree(options.staging, workDir);
+		const result = await commitAndPush(workDir, branch, options.sourceSha, {
+			commitTitle: options.commitTitle,
+			authorName: options.authorName,
+			authorEmail: options.authorEmail
+		});
+		if (!result.pushed) return {
+			status: "noop",
+			reason: result.reason
+		};
+		return {
+			status: "pushed",
+			mirrorSha: result.sha ?? void 0
+		};
+	} finally {
+		await fsp.rm(workDir, {
+			recursive: true,
+			force: true
+		});
+	}
+}
+/**
+* Initialize a local git working tree at `dir` whose `origin` is `mirrorUrl`
+* and whose HEAD is a fresh commit of `dir`'s contents. Used by `build:desktop`
+* to make the seed inside the .app a real git repo, so the user's apps-dir
+* after first launch can later `git pull` from the mirror.
+*
+* The commit SHA produced here is local-only; on the user's machine, after a
+* future `zen pull`, they'll fast-forward to whatever's actually on the
+* mirror.
+*/
+async function initSeedRepo(options) {
+	const branch = options.branch ?? "main";
+	const env = {
+		...process.env,
+		GIT_TERMINAL_PROMPT: "0"
+	};
+	if (!fs.existsSync(path.join(options.dir, ".git"))) await execFile$1("git", [
+		"init",
+		"-b",
+		branch
+	], {
+		cwd: options.dir,
+		env
+	});
+	await execFile$1("git", [
+		"remote",
+		"remove",
+		"origin"
+	], {
+		cwd: options.dir,
+		env
+	}).catch(() => {});
+	await execFile$1("git", [
+		"remote",
+		"add",
+		"origin",
+		options.mirrorUrl
+	], {
+		cwd: options.dir,
+		env
+	});
+	await execFile$1("git", ["add", "-A"], {
+		cwd: options.dir,
+		env
+	});
+	const localEnv = {
+		...env,
+		GIT_AUTHOR_NAME: "zenbu",
+		GIT_COMMITTER_NAME: "zenbu",
+		GIT_AUTHOR_EMAIL: "zenbu@local",
+		GIT_COMMITTER_EMAIL: "zenbu@local"
+	};
+	await execFile$1("git", [
+		"commit",
+		"--allow-empty",
+		"-m",
+		`seed ${options.sourceSha.slice(0, 7)}\n\n[synced from ${options.sourceSha}]\n`
+	], {
+		cwd: options.dir,
+		env: localEnv
+	});
+}
+/** Hash a directory tree's content; used by `build:source` for the .sha file. */
+async function hashDir(dir) {
+	const hash = crypto.createHash("sha256");
+	const entries = [];
+	await collectFiles(dir, dir, entries);
+	entries.sort();
+	for (const rel of entries) {
+		const buf = await fsp.readFile(path.join(dir, rel));
+		hash.update(rel);
+		hash.update("\0");
+		hash.update(buf);
+		hash.update("\0");
+	}
+	return hash.digest("hex");
+}
+async function collectFiles(root, dir, out) {
+	const entries = await fsp.readdir(dir, { withFileTypes: true });
+	for (const entry of entries) {
+		if (entry.name === ".git") continue;
+		const full = path.join(dir, entry.name);
+		if (entry.isDirectory()) await collectFiles(root, full, out);
+		else if (entry.isFile()) out.push(path.relative(root, full).split(path.sep).join("/"));
+	}
+}
+//#endregion
+export { findBuildConfig as a, push as i, init as n, loadBuildConfig as o, initSeedRepo as r, hashDir as t };