@zenbujs/core 0.0.13 → 0.0.15

package/dist/launcher.mjs

@@ -6070,7 +6070,7 @@ var require_isomorphic_git = /* @__PURE__ */ __commonJSMin(((exports) => {
 	var pako = _interopDefault(require_pako());
 	var crypto$1$1 = __require("crypto");
 	var pify = _interopDefault(require_pify());
-	var ignore = _interopDefault(require_ignore());
+	_interopDefault(require_ignore());
 	var cleanGitRef = _interopDefault(require_lib());
 	_interopDefault(require_diff3());
 	/**
@@ -9964,54 +9964,6 @@ ${obj.gpgsig ? obj.gpgsig : ""}`;
 		});
 		else return dotgit;
 	}
-	var GitIgnoreManager = class {
-		/**
-		* Determines whether a given file is ignored based on `.gitignore` rules and exclusion files.
-		*
-		* @param {Object} args
-		* @param {FSClient} args.fs - A file system implementation.
-		* @param {string} args.dir - The working directory.
-		* @param {string} [args.gitdir=join(dir, '.git')] - [required] The [git directory](dir-vs-gitdir.md) path
-		* @param {string} args.filepath - The path of the file to check.
-		* @returns {Promise<boolean>} - `true` if the file is ignored, `false` otherwise.
-		*/
-		static async isIgnored({ fs, dir, gitdir = join(dir, ".git"), filepath }) {
-			if (basename(filepath) === ".git") return true;
-			if (filepath === ".") return false;
-			let excludes = "";
-			const excludesFile = join(gitdir, "info", "exclude");
-			if (await fs.exists(excludesFile)) excludes = await fs.read(excludesFile, "utf8");
-			const pairs = [{
-				gitignore: join(dir, ".gitignore"),
-				filepath
-			}];
-			const pieces = filepath.split("/").filter(Boolean);
-			for (let i = 1; i < pieces.length; i++) {
-				const folder = pieces.slice(0, i).join("/");
-				const file = pieces.slice(i).join("/");
-				pairs.push({
-					gitignore: join(dir, folder, ".gitignore"),
-					filepath: file
-				});
-			}
-			let ignoredStatus = false;
-			for (const p of pairs) {
-				let file;
-				try {
-					file = await fs.read(p.gitignore, "utf8");
-				} catch (err) {
-					if (err.code === "NOENT") continue;
-				}
-				const ign = ignore().add(excludes);
-				ign.add(file);
-				const parentdir = dirname(p.filepath);
-				if (parentdir !== "." && ign.ignores(parentdir)) return true;
-				if (ignoredStatus) ignoredStatus = !ign.test(p.filepath).unignored;
-				else ignoredStatus = ign.test(p.filepath).ignored;
-			}
-			return ignoredStatus;
-		}
-	};
 	async function resolveCommit({ fs, cache, gitdir, oid }) {
 		const { type, object } = await _readObject({
 			fs,
@@ -12347,225 +12299,12 @@ ${obj.gpgsig ? obj.gpgsig : ""}`;
 			throw err;
 		}
 	}
-	/**
-	* Efficiently get the status of multiple files at once.
-	*
-	* The returned `StatusMatrix` is admittedly not the easiest format to read.
-	* However it conveys a large amount of information in dense format that should make it easy to create reports about the current state of the repository;
-	* without having to do multiple, time-consuming isomorphic-git calls.
-	* My hope is that the speed and flexibility of the function will make up for the learning curve of interpreting the return value.
-	*
-	* ```js live
-	* // get the status of all the files in 'src'
-	* let status = await git.statusMatrix({
-	*   fs,
-	*   dir: '/tutorial',
-	*   filter: f => f.startsWith('src/')
-	* })
-	* console.log(status)
-	* ```
-	*
-	* ```js live
-	* // get the status of all the JSON and Markdown files
-	* let status = await git.statusMatrix({
-	*   fs,
-	*   dir: '/tutorial',
-	*   filter: f => f.endsWith('.json') || f.endsWith('.md')
-	* })
-	* console.log(status)
-	* ```
-	*
-	* The result is returned as a 2D array.
-	* The outer array represents the files and/or blobs in the repo, in alphabetical order.
-	* The inner arrays describe the status of the file:
-	* the first value is the filepath, and the next three are integers
-	* representing the HEAD status, WORKDIR status, and STAGE status of the entry.
-	*
-	* ```js
-	* // example StatusMatrix
-	* [
-	*   ["a.txt", 0, 2, 0], // new, untracked
-	*   ["b.txt", 0, 2, 2], // added, staged
-	*   ["c.txt", 0, 2, 3], // added, staged, with unstaged changes
-	*   ["d.txt", 1, 1, 1], // unmodified
-	*   ["e.txt", 1, 2, 1], // modified, unstaged
-	*   ["f.txt", 1, 2, 2], // modified, staged
-	*   ["g.txt", 1, 2, 3], // modified, staged, with unstaged changes
-	*   ["h.txt", 1, 0, 1], // deleted, unstaged
-	*   ["i.txt", 1, 0, 0], // deleted, staged
-	*   ["j.txt", 1, 2, 0], // deleted, staged, with unstaged-modified changes (new file of the same name)
-	*   ["k.txt", 1, 1, 0], // deleted, staged, with unstaged changes (new file of the same name)
-	* ]
-	* ```
-	*
-	* - The HEAD status is either absent (0) or present (1).
-	* - The WORKDIR status is either absent (0), identical to HEAD (1), or different from HEAD (2).
-	* - The STAGE status is either absent (0), identical to HEAD (1), identical to WORKDIR (2), or different from WORKDIR (3).
-	*
-	* ```ts
-	* type Filename      = string
-	* type HeadStatus    = 0 | 1
-	* type WorkdirStatus = 0 | 1 | 2
-	* type StageStatus   = 0 | 1 | 2 | 3
-	*
-	* type StatusRow     = [Filename, HeadStatus, WorkdirStatus, StageStatus]
-	*
-	* type StatusMatrix  = StatusRow[]
-	* ```
-	*
-	* > Think of the natural progression of file modifications as being from HEAD (previous) -> WORKDIR (current) -> STAGE (next).
-	* > Then HEAD is "version 1", WORKDIR is "version 2", and STAGE is "version 3".
-	* > Then, imagine a "version 0" which is before the file was created.
-	* > Then the status value in each column corresponds to the oldest version of the file it is identical to.
-	* > (For a file to be identical to "version 0" means the file is deleted.)
-	*
-	* Here are some examples of queries you can answer using the result:
-	*
-	* #### Q: What files have been deleted?
-	* ```js
-	* const FILE = 0, WORKDIR = 2
-	*
-	* const filenames = (await statusMatrix({ dir }))
-	*   .filter(row => row[WORKDIR] === 0)
-	*   .map(row => row[FILE])
-	* ```
-	*
-	* #### Q: What files have unstaged changes?
-	* ```js
-	* const FILE = 0, WORKDIR = 2, STAGE = 3
-	*
-	* const filenames = (await statusMatrix({ dir }))
-	*   .filter(row => row[WORKDIR] !== row[STAGE])
-	*   .map(row => row[FILE])
-	* ```
-	*
-	* #### Q: What files have been modified since the last commit?
-	* ```js
-	* const FILE = 0, HEAD = 1, WORKDIR = 2
-	*
-	* const filenames = (await statusMatrix({ dir }))
-	*   .filter(row => row[HEAD] !== row[WORKDIR])
-	*   .map(row => row[FILE])
-	* ```
-	*
-	* #### Q: What files will NOT be changed if I commit right now?
-	* ```js
-	* const FILE = 0, HEAD = 1, STAGE = 3
-	*
-	* const filenames = (await statusMatrix({ dir }))
-	*   .filter(row => row[HEAD] === row[STAGE])
-	*   .map(row => row[FILE])
-	* ```
-	*
-	* For reference, here are all possible combinations:
-	*
-	* | HEAD | WORKDIR | STAGE | `git status --short` equivalent |
-	* | ---- | ------- | ----- | ------------------------------- |
-	* | 0    | 0       | 0     | ``                              |
-	* | 0    | 0       | 3     | `AD`                            |
-	* | 0    | 2       | 0     | `??`                            |
-	* | 0    | 2       | 2     | `A `                            |
-	* | 0    | 2       | 3     | `AM`                            |
-	* | 1    | 0       | 0     | `D `                            |
-	* | 1    | 0       | 1     | ` D`                            |
-	* | 1    | 0       | 3     | `MD`                            |
-	* | 1    | 1       | 0     | `D ` + `??`                     |
-	* | 1    | 1       | 1     | ``                              |
-	* | 1    | 1       | 3     | `MM`                            |
-	* | 1    | 2       | 0     | `D ` + `??`                     |
-	* | 1    | 2       | 1     | ` M`                            |
-	* | 1    | 2       | 2     | `M `                            |
-	* | 1    | 2       | 3     | `MM`                            |
-	*
-	* @param {object} args
-	* @param {FsClient} args.fs - a file system client
-	* @param {string} args.dir - The [working tree](dir-vs-gitdir.md) directory path
-	* @param {string} [args.gitdir=join(dir, '.git')] - [required] The [git directory](dir-vs-gitdir.md) path
-	* @param {string} [args.ref = 'HEAD'] - Optionally specify a different commit to compare against the workdir and stage instead of the HEAD
-	* @param {string[]} [args.filepaths = ['.']] - Limit the query to the given files and directories
-	* @param {function(string): boolean} [args.filter] - Filter the results to only those whose filepath matches a function.
-	* @param {object} [args.cache] - a [cache](cache.md) object
-	* @param {boolean} [args.ignored = false] - include ignored files in the result
-	*
-	* @returns {Promise<Array<StatusRow>>} Resolves with a status matrix, described below.
-	* @see StatusRow
-	*/
-	async function statusMatrix({ fs: _fs, dir, gitdir = join(dir, ".git"), ref = "HEAD", filepaths = ["."], filter, cache = {}, ignored: shouldIgnore = false }) {
-		try {
-			assertParameter("fs", _fs);
-			assertParameter("gitdir", gitdir);
-			assertParameter("ref", ref);
-			const fs = new FileSystem(_fs);
-			return await _walk({
-				fs,
-				cache,
-				dir,
-				gitdir: await discoverGitdir({
-					fsp: fs,
-					dotgit: gitdir
-				}),
-				trees: [
-					TREE({ ref }),
-					WORKDIR(),
-					STAGE()
-				],
-				map: async function(filepath, [head, workdir, stage]) {
-					if (!head && !stage && workdir) {
-						if (!shouldIgnore) {
-							if (await GitIgnoreManager.isIgnored({
-								fs,
-								dir,
-								filepath
-							})) return null;
-						}
-					}
-					if (!filepaths.some((base) => worthWalking(filepath, base))) return null;
-					if (filter) {
-						if (!filter(filepath)) return;
-					}
-					const [headType, workdirType, stageType] = await Promise.all([
-						head && head.type(),
-						workdir && workdir.type(),
-						stage && stage.type()
-					]);
-					const isBlob = [
-						headType,
-						workdirType,
-						stageType
-					].includes("blob");
-					if ((headType === "tree" || headType === "special") && !isBlob) return;
-					if (headType === "commit") return null;
-					if ((workdirType === "tree" || workdirType === "special") && !isBlob) return;
-					if (stageType === "commit") return null;
-					if ((stageType === "tree" || stageType === "special") && !isBlob) return;
-					const headOid = headType === "blob" ? await head.oid() : void 0;
-					const stageOid = stageType === "blob" ? await stage.oid() : void 0;
-					let workdirOid;
-					if (headType !== "blob" && workdirType === "blob" && stageType !== "blob") workdirOid = "42";
-					else if (workdirType === "blob") workdirOid = await workdir.oid();
-					const entry = [
-						void 0,
-						headOid,
-						workdirOid,
-						stageOid
-					];
-					const result = entry.map((value) => entry.indexOf(value));
-					result.shift();
-					return [filepath, ...result];
-				}
-			});
-		} catch (err) {
-			err.caller = "git.statusMatrix";
-			throw err;
-		}
-	}
 	exports.checkout = checkout;
 	exports.clone = clone;
 	exports.fetch = fetch;
 	exports.log = log;
 	exports.readBlob = readBlob;
 	exports.resolveRef = resolveRef;
-	exports.statusMatrix = statusMatrix;
 }));
 //#endregion
 //#region ../../node_modules/.pnpm/simple-concat@1.0.1/node_modules/simple-concat/index.js
@@ -18545,10 +18284,42 @@ function electronTargetVersion(appsDir) {
 		return "42.0.0";
 	}
 }
-function buildInstallEnv(appsDir) {
+/**
+* Build the env used to spawn `pnpm install` (and friends) on first
+* launch. The bundled toolchain (`<resourcesPath>/toolchain/`) holds
+* `node` and `bun` binaries; we prepend that dir to PATH so dependency
+* install hooks with `#!/usr/bin/env node` shebangs (`@parcel/watcher`,
+* `dugite`, etc.) resolve to the bundled node regardless of how the
+* .app was launched.
+*
+* GUI launches (Finder, Raycast, Spotlight, `open <app>`) inherit a
+* stripped PATH like `/usr/bin:/bin:/usr/sbin:/sbin`, so without this
+* prepend the lifecycle scripts crash with `node: command not found`.
+* We also baseline-merge the standard system bin dirs in case the
+* inherited PATH lacks them entirely.
+*/
+function buildInstallEnv(appsDir, resourcesPath) {
 	const target = electronTargetVersion(appsDir);
+	const sep = process.platform === "win32" ? ";" : ":";
+	const baselinePath = process.env.PATH ?? process.env.Path ?? "";
+	const toolchainDir = resourcesPath ? path.join(resourcesPath, "toolchain") : null;
+	const systemDirs = process.platform === "win32" ? [] : [
+		"/usr/local/bin",
+		"/usr/bin",
+		"/bin",
+		"/usr/sbin",
+		"/sbin"
+	];
+	const segments = [];
+	if (toolchainDir) segments.push(toolchainDir);
+	if (baselinePath) segments.push(...baselinePath.split(sep));
+	segments.push(...systemDirs);
+	const seen = /* @__PURE__ */ new Set();
+	const PATH = segments.filter((s) => s && !seen.has(s) && seen.add(s)).join(sep);
 	return {
 		...process.env,
+		PATH,
+		Path: PATH,
 		CI: "true",
 		HOME: path.join(appsDir, ".zenbu", ".node-gyp"),
 		npm_config_runtime: "electron",
@@ -18659,7 +18430,7 @@ function spawnInstall(args) {
 }
 async function runInstall(opts) {
 	const { appsDir, resourcesPath, pm, reporter = null, signal } = opts;
-	const env = buildInstallEnv(appsDir);
+	const env = buildInstallEnv(appsDir, resourcesPath);
 	const entry = bundledPmEntry(pm, resourcesPath);
 	switch (pm.type) {
 		case "pnpm": {
@@ -20656,20 +20427,6 @@ function resolveMirror(cfg) {
 function isExistingClone(dir) {
 	return existsSync(path.join(dir, ".git", "HEAD"));
 }
-/**
-* True if the working tree has uncommitted modifications. We use this as a
-* "respect the user's edits" guard before fast-forwarding from origin.
-*/
-async function hasLocalModifications(dir) {
-	try {
-		return (await import_isomorphic_git.statusMatrix({
-			fs,
-			dir
-		})).some(([, head, workdir, stage]) => head !== 1 || workdir !== 1 || stage !== 1);
-	} catch {
-		return false;
-	}
-}
 async function cloneMirror(dir, mirror, installer) {
 	console.log(`[launcher] cloning ${mirror.url}#${mirror.branch} -> ${dir}`);
 	installer?.step("clone", `Cloning ${mirror.url}#${mirror.branch}`);
@@ -20697,41 +20454,6 @@ async function cloneMirror(dir, mirror, installer) {
 	installer?.done("clone");
 }
 /**
-* Best-effort `git fetch --depth=1` against `origin/<branch>`. Failures
-* are non-fatal — the resolver runs next and may still find a local
-* compatible commit on a previously-deepened working tree. Skips the
-* remote checkout entirely (the resolver decides which sha to land on).
-*/
-async function fetchTip(dir, mirror, installer) {
-	installer?.step("fetch", `Updating from ${mirror.url}#${mirror.branch}`);
-	try {
-		await import_isomorphic_git.fetch({
-			fs,
-			http: index,
-			dir,
-			url: mirror.url,
-			ref: mirror.branch,
-			singleBranch: true,
-			depth: 1,
-			tags: false,
-			onProgress: installer ? (e) => {
-				const ratio = e.total ? e.loaded / e.total : void 0;
-				installer.progress({
-					phase: e.phase,
-					loaded: e.loaded,
-					total: e.total,
-					ratio
-				});
-			} : void 0,
-			onMessage: installer ? (msg) => installer.message(msg.replace(/\n+$/g, "")) : void 0
-		});
-	} catch (err) {
-		console.warn(`[launcher] fetch failed (${err.message}); using local state`);
-	} finally {
-		installer?.done("fetch");
-	}
-}
-/**
 * Resolve the latest commit on origin/<branch> whose
 * `package.json#zenbu.host` satisfies the running .app's `hostVersion`,
 * and check it out if HEAD isn't already there. Pure delegation to
@@ -20772,20 +20494,12 @@ async function resolveAndCheckout(dir, mirror, hostVersion, installer) {
 	});
 }
 async function ensureAppsDir(appsDir, mirror, hostVersion, installer) {
-	if (isExistingClone(appsDir)) {
-		if (await hasLocalModifications(appsDir)) {
-			console.warn(`[launcher] working tree at ${appsDir} has uncommitted modifications; skipping fetch + resolve.`);
-			installer?.message(`[launcher] uncommitted modifications detected; skipping update`);
-			return;
-		}
-		await fetchTip(appsDir, mirror, installer);
-	} else {
-		if (existsSync(appsDir)) {
-			const entries = await fsp.readdir(appsDir).catch(() => []);
-			if (entries.length > 0) throw new Error(`[launcher] ${appsDir} exists and isn't a git working tree (has ${entries.length} entries). Move or delete it, then relaunch.`);
-		}
-		await cloneMirror(appsDir, mirror, installer);
+	if (isExistingClone(appsDir)) return;
+	if (existsSync(appsDir)) {
+		const entries = await fsp.readdir(appsDir).catch(() => []);
+		if (entries.length > 0) throw new Error(`[launcher] ${appsDir} exists and isn't a git working tree (has ${entries.length} entries). Move or delete it, then relaunch.`);
 	}
+	await cloneMirror(appsDir, mirror, installer);
 	await resolveAndCheckout(appsDir, mirror, hostVersion, installer);
 }
 async function ensureDepsInstalled(appsDir, pm, installer) {

package/dist/services/default.mjs

@@ -13,7 +13,7 @@ async function defaultServices() {
 	await import("../renderer-host-Cw38dSDe.mjs").then((n) => n.i);
 	await import("../window-DgB70qeZ.mjs").then((n) => n.n);
 	await import("../runtime-DYUONc3S.mjs").then((n) => n.h);
-	await import("../updater-Bs1Jtem6.mjs").then((n) => n.n);
+	await import("../updater-C6mWMmb5.mjs").then((n) => n.n);
 }
 //#endregion
 export { defaultServices };

package/dist/services/index.mjs

@@ -4,5 +4,5 @@ import { a as DbService, r as ViewRegistryService, s as HttpService, t as Render
 import { n as MAIN_WINDOW_ID, t as BaseWindowService } from "../base-window-4P-fVvC_.mjs";
 import { t as RpcService } from "../rpc-Dg9zwZ33.mjs";
 import { t as WindowService } from "../window-DgB70qeZ.mjs";
-import { t as UpdaterService } from "../updater-Bs1Jtem6.mjs";
+import { t as UpdaterService } from "../updater-C6mWMmb5.mjs";
 export { BaseWindowService, DbService, HttpService, MAIN_WINDOW_ID, ReloaderService, RendererHostService, RpcService, ServerService, UpdaterService, ViewRegistryService, WindowService };

package/dist/{updater-Bs1Jtem6.mjs → updater-C6mWMmb5.mjs}

@@ -94,10 +94,42 @@ function electronTargetVersion(appsDir) {
 		return "42.0.0";
 	}
 }
-function buildInstallEnv(appsDir) {
+/**
+* Build the env used to spawn `pnpm install` (and friends) on first
+* launch. The bundled toolchain (`<resourcesPath>/toolchain/`) holds
+* `node` and `bun` binaries; we prepend that dir to PATH so dependency
+* install hooks with `#!/usr/bin/env node` shebangs (`@parcel/watcher`,
+* `dugite`, etc.) resolve to the bundled node regardless of how the
+* .app was launched.
+*
+* GUI launches (Finder, Raycast, Spotlight, `open <app>`) inherit a
+* stripped PATH like `/usr/bin:/bin:/usr/sbin:/sbin`, so without this
+* prepend the lifecycle scripts crash with `node: command not found`.
+* We also baseline-merge the standard system bin dirs in case the
+* inherited PATH lacks them entirely.
+*/
+function buildInstallEnv(appsDir, resourcesPath) {
 	const target = electronTargetVersion(appsDir);
+	const sep = process.platform === "win32" ? ";" : ":";
+	const baselinePath = process.env.PATH ?? process.env.Path ?? "";
+	const toolchainDir = resourcesPath ? path.join(resourcesPath, "toolchain") : null;
+	const systemDirs = process.platform === "win32" ? [] : [
+		"/usr/local/bin",
+		"/usr/bin",
+		"/bin",
+		"/usr/sbin",
+		"/sbin"
+	];
+	const segments = [];
+	if (toolchainDir) segments.push(toolchainDir);
+	if (baselinePath) segments.push(...baselinePath.split(sep));
+	segments.push(...systemDirs);
+	const seen = /* @__PURE__ */ new Set();
+	const PATH = segments.filter((s) => s && !seen.has(s) && seen.add(s)).join(sep);
 	return {
 		...process.env,
+		PATH,
+		Path: PATH,
 		CI: "true",
 		HOME: path.join(appsDir, ".zenbu", ".node-gyp"),
 		npm_config_runtime: "electron",
@@ -208,7 +240,7 @@ function spawnInstall(args) {
 }
 async function runInstall(opts) {
 	const { appsDir, resourcesPath, pm, reporter = null, signal } = opts;
-	const env = buildInstallEnv(appsDir);
+	const env = buildInstallEnv(appsDir, resourcesPath);
 	const entry = bundledPmEntry(pm, resourcesPath);
 	switch (pm.type) {
 		case "pnpm": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zenbujs/core",
-  "version": "0.0.13",
+  "version": "0.0.15",
   "type": "module",
   "publishConfig": {
     "access": "public"