@gjsify/cli 0.41.0 → 0.43.0

package/lib/utils/watch-loop.js

@@ -0,0 +1,207 @@
+// The watch → rebuild → relaunch loop, shared by `gjsify storybook --watch` and
+// `gjsify dev`.
+//
+// It lives here rather than in either command because it is the whole Node-free
+// inner development cycle and `gjsify build --watch` cannot be it: rolldown's
+// watcher API is npm-engine-only (`bundler-pick.ts` refuses under
+// `@gjsify/rolldown-native`), so the one path that watches is the one running on
+// the host that does not need it. This loop asks the bundler for no watcher at
+// all — `fs.watch` reports the change and the rebuild is an in-process re-entry
+// of the ordinary build command, which is runtime-agnostic.
+import { watch } from 'node:fs';
+import { dirname, resolve, sep } from 'node:path';
+import { holdMainLoop } from '@gjsify/utils/main-loop';
+import { markDaemonCommand } from './daemon-command.js';
+import { spawnToCompletion } from './spawn.js';
+import { RUNTIMES } from './runtimes.js';
+/**
+ * Start a child the caller SUPERVISES rather than waits for.
+ *
+ * `completion: 'daemon'` is the third row of the teardown table: a watch loop
+ * neither exits nor unwinds, so the armed GJS main loop is not a leak here —
+ * it is what keeps the session alive. The handle arrives synchronously through
+ * `onSpawn`; the completion promise is deliberately never awaited (it settles
+ * when the child is killed for the next rebuild), only its REJECTION is routed
+ * out, so a missing interpreter still surfaces as a rebuild failure.
+ */
+export function spawnSupervised(cmd, cmdArgs, env) {
+    return new Promise((resolveChild, reject) => {
+        void spawnToCompletion(cmd, cmdArgs, { completion: 'daemon', env, onSpawn: resolveChild }).catch(reject);
+    });
+}
+/**
+ * Launch a built bundle as a supervised child on `runtime`, wired the way
+ * `gjsify run` would launch it for real: `gjs -m` for the `--app gjs` bundle,
+ * the `--app node` bundle on node/bun/deno, and in BOTH cases the native
+ * typelib/library environment for any `@gjsify` native package the bundle
+ * reaches. The env is not optional on the gjs arm either — a watch loop that
+ * skipped it would run an app that `gjsify run` can start and this cannot.
+ *
+ * `subject` names what is being run in the node-gi diagnostic ("the storybook",
+ * "this project").
+ */
+export async function spawnBundleSupervised(runtime, bundlePath, cwd, subject) {
+    if (runtime !== 'gjs') {
+        // Only a bundle that actually reaches gi:// needs the reverse bridge;
+        // the bundler keeps `@gjsify/node-gi` external, so its presence in the
+        // output is the question. A plain Node app must run without it.
+        const { bundleRequiresNodeGi, resolveNodeGiForBundle } = await import('./run-node.js');
+        // Same resolution base as `runRuntimeBundle`: the bundle's own dir first
+        // (that is where the runtime resolves the external specifier from), cwd
+        // as the fallback.
+        if (bundleRequiresNodeGi(bundlePath) && !resolveNodeGiForBundle(bundlePath, cwd)) {
+            throw new Error(`Cannot run ${subject} on ${runtime}: \`@gjsify/node-gi\` is not installed. ` +
+                `Add @gjsify/node-gi as a dependency to run ${subject} on ${runtime}.`);
+        }
+    }
+    const { computeNativeEnvForBundle } = await import('./run-gjs.js');
+    const { env: nativeEnv } = computeNativeEnvForBundle(bundlePath, cwd);
+    const env = { ...process.env, ...nativeEnv };
+    if (runtime === 'gjs') {
+        return spawnSupervised('gjs', ['-m', bundlePath], env);
+    }
+    // `node` uses the resolved node binary (under a GJS-hosted CLI
+    // `process.execPath` is gjs); bun/deno launch via the shared spec (deno's
+    // `--node-modules-dir=manual`, etc.).
+    if (runtime === 'node') {
+        const { nodeBinary } = await import('./run-node.js');
+        return spawnSupervised(nodeBinary(), [bundlePath], env);
+    }
+    const [cmd, launchArgs] = RUNTIMES[runtime].launch(bundlePath);
+    return spawnSupervised(cmd, launchArgs, env);
+}
+/**
+ * Whether a watcher event is the loop's OWN output rather than a source edit.
+ *
+ * Without this the loop feeds itself whenever the bundle lands inside the
+ * watched tree, which is the DEFAULT arrangement rather than an exotic one: the
+ * watch dir defaults to the entry point's directory, so `gjsify dev index.ts` on
+ * a project building to `dist/` watches the project root and every build it runs
+ * is a change under it. Measured before this filter: one edit to `index.ts`
+ * started a rebuild every ~5 s that never stopped.
+ *
+ * Two shapes, because a build writes more than the file it is named after:
+ *
+ *  - the bundle itself and anything sharing its stem (`out.mjs.map`), which the
+ *    bundler writes beside it in the same pass;
+ *  - the whole output DIRECTORY — but only when it is not the watched directory
+ *    itself. `--outfile dist/out.mjs` under a watch dir of `.` puts chunks and
+ *    assets there too; an `--outfile` written straight into the watched dir has
+ *    no directory to exclude that would not also exclude the sources.
+ *
+ * `filename` is what `fs.watch` reports, relative to `dir` — `null` on the
+ * platforms that cannot name the changed path, where the honest answer is "no
+ * idea", i.e. rebuild.
+ *
+ * BOTH operands are resolved before they are compared. Resolving only the
+ * changed path is right on POSIX for as long as every caller happens to pass an
+ * already-absolute `output`, and silently wrong the moment one does not: on
+ * win32 `resolve()` also rewrites the separators and picks up the drive, so the
+ * two sides stop being the same spelling of the same file and every self-write
+ * reads as a source edit — which is the feedback loop this filter exists to
+ * stop. Caught by the win32 leg; on Linux all five cases passed.
+ */
+export function isSelfWrite(dir, output, filename) {
+    if (output === undefined || filename === null)
+        return false;
+    const changed = resolve(dir, filename);
+    const out = resolve(dir, output);
+    if (changed === out || changed.startsWith(`${out}.`))
+        return true;
+    const outDir = dirname(out);
+    if (outDir === resolve(dir))
+        return false;
+    return changed === outDir || changed.startsWith(`${outDir}${sep}`);
+}
+/**
+ * Run the loop: build + launch once, then rebuild + relaunch on every change
+ * under `dir`. Returns once the watcher is armed; the process is then held open
+ * — by the watcher handle on Node, by the GLib main loop on GJS — so there is
+ * nothing left to await. That the RESOLUTION is not completion is the one thing
+ * a caller has to know, which is why it is also declared through
+ * `markDaemonCommand()` for the callers that cannot see this signature.
+ *
+ * A build failure is reported and the loop KEEPS WATCHING: the next save is the
+ * fix, and a dev loop that dies on a syntax error is a dev loop nobody uses.
+ */
+export async function runWatchLoop(opts) {
+    const { dir, label, prepare, build, spawnChild, output, debounceMs = 200 } = opts;
+    // Say so BEFORE the first build: `gjsify run`'s in-process dispatch acts on
+    // this the moment the handler resolves, and a first build that throws still
+    // leaves the loop watching.
+    markDaemonCommand();
+    let child = null;
+    let rebuilding = false;
+    let pending = false;
+    const rebuild = async () => {
+        if (rebuilding) {
+            pending = true;
+            return;
+        }
+        rebuilding = true;
+        try {
+            if (prepare)
+                await prepare();
+            if (child) {
+                child.kill();
+                child = null;
+            }
+            await build();
+            if (spawnChild) {
+                child = await spawnChild();
+            }
+        }
+        catch (err) {
+            console.error(`[${label}] rebuild failed: ${err.message}`);
+        }
+        finally {
+            rebuilding = false;
+            if (pending) {
+                pending = false;
+                void rebuild();
+            }
+        }
+    };
+    await rebuild();
+    let debounce = null;
+    const watcher = watch(dir, { recursive: true }, (_event, filename) => {
+        if (isSelfWrite(dir, output, typeof filename === 'string' ? filename : null))
+            return;
+        if (debounce)
+            clearTimeout(debounce);
+        debounce = setTimeout(() => void rebuild(), debounceMs);
+    });
+    // Under GJS nothing else keeps us here. An `fs.watch` handle is a Gio file
+    // monitor, not a Node handle count, and the supervised spawn's own
+    // `ensureMainLoop()` declines to arm anything: it is reached from a
+    // continuation that GJS resumed from inside the main-context spin it runs
+    // while our entry module's top-level await is pending, where
+    // `GLib.main_depth()` is 1. So the loop used to print "watching …" and exit
+    // 0 on the very host `gjsify dev` exists for, leaving the app orphaned.
+    // `holdMainLoop()` is the opt-in that arms it anyway; `shutdown()` below is
+    // what takes it back down.
+    holdMainLoop();
+    // Ctrl+C is how this command ENDS, so the supervised child has to be taken
+    // down with it: the loop spawns the app in the CLI's own process group, and
+    // a SIGINT delivered to the CLI alone leaves a live GTK window behind with
+    // nothing watching it. Registering a handler also removes Node's default
+    // terminate, so the exit has to be explicit — and under GJS it is required
+    // anyway, since the loop held above is what is keeping us alive. Delivery
+    // there is `@gjsify/process` arming a `GLibUnix.signal_add()` source on the
+    // first listener, which dispatches on that same held loop; before it existed
+    // these two lines registered listeners nothing ever emitted.
+    let stopping = false;
+    const shutdown = () => {
+        if (stopping)
+            return;
+        stopping = true;
+        if (debounce)
+            clearTimeout(debounce);
+        child?.kill();
+        watcher.close();
+        process.exit(0);
+    };
+    process.on('SIGINT', shutdown);
+    process.on('SIGTERM', shutdown);
+    console.log(`[${label}] watching ${opts.dirLabel ?? dir} — press Ctrl+C to stop`);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@gjsify/cli",
-    "version": "0.41.0",
+    "version": "0.43.0",
     "description": "CLI for Gjsify",
     "type": "module",
     "main": "lib/index.js",
@@ -142,20 +142,21 @@
         "cli"
     ],
     "dependencies": {
-        "@gjsify/buffer": "^0.41.0",
-        "@gjsify/create-app": "^0.41.0",
-        "@gjsify/node-globals": "^0.41.0",
-        "@gjsify/node-polyfills": "^0.41.0",
-        "@gjsify/npm-registry": "^0.41.0",
-        "@gjsify/resolve-npm": "^0.41.0",
-        "@gjsify/rolldown-plugin-gjsify": "^0.41.0",
-        "@gjsify/vite-plugin-blueprint": "^0.41.0",
-        "@gjsify/rolldown-plugin-pnp": "^0.41.0",
-        "@gjsify/semver": "^0.41.0",
-        "@gjsify/tar": "^0.41.0",
-        "@gjsify/tsc": "^0.41.0",
-        "@gjsify/web-polyfills": "^0.41.0",
-        "@gjsify/workspace": "^0.41.0",
+        "@gjsify/buffer": "^0.43.0",
+        "@gjsify/create-app": "^0.43.0",
+        "@gjsify/node-globals": "^0.43.0",
+        "@gjsify/node-polyfills": "^0.43.0",
+        "@gjsify/npm-registry": "^0.43.0",
+        "@gjsify/resolve-npm": "^0.43.0",
+        "@gjsify/rolldown-plugin-gjsify": "^0.43.0",
+        "@gjsify/vite-plugin-blueprint": "^0.43.0",
+        "@gjsify/rolldown-plugin-pnp": "^0.43.0",
+        "@gjsify/semver": "^0.43.0",
+        "@gjsify/tar": "^0.43.0",
+        "@gjsify/tsc": "^0.43.0",
+        "@gjsify/utils": "^0.43.0",
+        "@gjsify/web-polyfills": "^0.43.0",
+        "@gjsify/workspace": "^0.43.0",
         "acorn": "^8.17.0",
         "cosmiconfig": "^9.0.2",
         "get-tsconfig": "^4.14.0",
@@ -164,13 +165,13 @@
         "yargs": "^18.0.0"
     },
     "devDependencies": {
-        "@gjsify/unit": "^0.41.0",
+        "@gjsify/unit": "^0.43.0",
         "@types/yargs": "^17.0.35",
         "typescript": "^6.0.3"
     },
     "peerDependencies": {
-        "@gjsify/oxfmt-native": "^0.41.0",
-        "@gjsify/rolldown-native": "^0.41.0"
+        "@gjsify/oxfmt-native": "^0.43.0",
+        "@gjsify/rolldown-native": "^0.43.0"
     },
     "peerDependenciesMeta": {
         "@gjsify/oxfmt-native": {

package/lib/templates/app/desktop.tmpl

@@ -1,10 +0,0 @@
-[Desktop Entry]
-Name={{NAME}}
-Comment={{SUMMARY}}
-Exec={{COMMAND}}
-Icon={{APP_ID}}
-Terminal=false
-Type=Application
-Categories={{CATEGORIES_LINE}}
-{{KEYWORDS_LINE}}{{MIMETYPES_LINE}}StartupNotify=true
-StartupWMClass={{APP_ID}}