nylorun 0.19.0-beta → 0.20.0-beta

package/dist/client/watch.js

@@ -0,0 +1,87 @@
+/**
+ * `nylorun apply --watch [--save]` (track T7, design §6): checks the folders and plans their
+ * manifests at once, then again on each change to them (debounced), until interrupted. It saves
+ * only with `--save`: each save is a new immutable version that moves the Agents tracking the
+ * name, so `--watch --save` is for a development manifest. A cycle that fails (a Runtime that
+ * refuses, a folder that does not pack) prints why and the watch goes on. The file a
+ * `runtime.json` `extends` is watched too.
+ */
+import { watch as watchFiles } from "node:fs";
+import { relative, resolve } from "node:path";
+import { applyCommand } from "./apply.js";
+import { agentFolders, checkCommand, packed } from "./folder.js";
+/** `node:fs` `watch`, recursive for a folder. */
+export const nodeWatcher = (paths, onChange) => {
+    const watchers = paths.map((path) => watchFiles(path, { recursive: true }, (_event, file) => onChange(file ? resolve(path, String(file)) : path)));
+    return { close: () => watchers.forEach((watcher) => watcher.close()) };
+};
+/** What changes that never start a cycle: version control and dependencies. */
+const QUIET = /(^|[\\/])(\.git|node_modules|\.hg|\.svn)([\\/]|$)/;
+/**
+ * Checks and plans `dirs` (apply's other flags in `args`) now and on each change, saving with
+ * `save`, until the signal ends it.
+ */
+export async function watchApply(deps, run, options = {}) {
+    const cwd = deps.cwd ?? process.cwd();
+    const dirs = run.dirs.length > 0 ? run.dirs : ["."];
+    const controller = new AbortController();
+    const signal = options.signal ?? controller.signal;
+    const stop = () => controller.abort();
+    if (!options.signal) {
+        process.once("SIGINT", stop);
+        process.once("SIGTERM", stop);
+    }
+    const cycle = async () => {
+        try {
+            if ((await checkCommand(deps, dirs)) === 0)
+                await applyCommand(deps, run.args, { planOnly: !run.save, checked: true });
+        }
+        catch (error) {
+            deps.err(error instanceof Error ? error.message : String(error));
+        }
+        deps.out(`Watching ${dirs.join(", ")} for changes${run.save ? ", saving each" : ""} (Ctrl-C stops).`);
+    };
+    // The folders, and the files their runtime.json extends.
+    const paths = new Set(dirs.map((dir) => resolve(cwd, dir)));
+    for (const dir of dirs)
+        for (const folder of await agentFolders(resolve(cwd, dir)).catch(() => []))
+            for (const file of (await packed(folder).catch(() => undefined))?.extended ?? [])
+                paths.add(file);
+    let running = cycle();
+    let timer;
+    let changed;
+    const watcher = (options.watcher ?? nodeWatcher)([...paths], (path) => {
+        if (QUIET.test(path))
+            return;
+        changed = path;
+        clearTimeout(timer);
+        timer = setTimeout(() => {
+            const what = changed;
+            running = running.then(async () => {
+                if (signal.aborted)
+                    return;
+                deps.out("");
+                deps.out(`${what === undefined ? "A file" : relative(cwd, what) || "."} changed: checking again.`);
+                await cycle();
+            });
+        }, options.debounceMs ?? 200);
+    });
+    try {
+        await new Promise((done) => {
+            if (signal.aborted)
+                done();
+            else
+                signal.addEventListener("abort", () => done(), { once: true });
+        });
+    }
+    finally {
+        clearTimeout(timer);
+        watcher.close();
+        if (!options.signal) {
+            process.off("SIGINT", stop);
+            process.off("SIGTERM", stop);
+        }
+    }
+    await running;
+    return 0;
+}

package/dist/nylo.js

@@ -3,7 +3,7 @@ import "./baseline.js";
 import { runCommand } from "./command.js";
 import { CliError } from "./errors.js";
 /**
- * `nylo` became part of `nylorun`. Until nylorun 0.19, which removes it, this command names the
+ * `nylo` became part of `nylorun`. Until a later release removes it, this command names the
  * `nylorun` command that replaces each of its own and exits 2.
  */
 const REPLACEMENTS = {
@@ -18,7 +18,7 @@ function nyloMessage(argv) {
     const replacement = REPLACEMENTS[argv[0] ?? ""];
     return `${replacement
         ? `nylo is part of nylorun now: nylo ${argv[0]} is ${replacement}.`
-        : "nylo is part of nylorun now: run nylorun --help."} nylorun 0.19 removes nylo.`;
+        : "nylo is part of nylorun now: run nylorun --help."} A later nylorun release removes nylo.`;
 }
 runCommand(async () => {
     throw new CliError(nyloMessage(process.argv.slice(2)), 2);

package/dist/stack/versions.d.ts

@@ -1,3 +1,5 @@
+/** This CLI's version, from its `package.json` (`nylorun --version`). */
+export declare function cliVersion(): string;
 /** An image this CLI release pins in its `package.json` `nylorun` (D7). */
 export type PinnedImage = "runtime" | "studio";
 /**

package/dist/stack/versions.js

@@ -6,6 +6,18 @@ function cliPackageJsonPath() {
     // src/stack/*.ts and dist/stack/*.js both sit two levels below the package root.
     return join(dirname(fileURLToPath(import.meta.url)), "..", "..", "package.json");
 }
+/** This CLI's version, from its `package.json` (`nylorun --version`). */
+export function cliVersion() {
+    try {
+        const version = JSON.parse(readFileSync(cliPackageJsonPath(), "utf8")).version;
+        if (typeof version === "string")
+            return version;
+    }
+    catch (error) {
+        throw new CliError(`Cannot read CLI package.json: ${error instanceof Error ? error.message : String(error)}`, 1);
+    }
+    throw new CliError("nylorun's package.json has no version.", 1);
+}
 /**
  * The version this CLI release pins for an image, from its `package.json`
  * `nylorun.runtime` or `nylorun.studio`: the tag of `ghcr.io/nylorun/<name>`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nylorun",
-  "version": "0.19.0-beta",
+  "version": "0.20.0-beta",
   "type": "module",
   "license": "Apache-2.0",
   "description": "Set up and run local Nylorun Tenants (Runtime and Studio) with Docker Compose, and act on a Tenant through its Runtime and Management APIs",
@@ -30,9 +30,9 @@
     "prepack": "npm run build"
   },
   "dependencies": {
-    "@nylorun/admin": "0.19.3-beta",
-    "@nylorun/agents": "0.27.0-beta",
-    "@nylorun/core": "0.27.0-beta"
+    "@nylorun/admin": "0.19.4-beta",
+    "@nylorun/agents": "0.28.0-beta",
+    "@nylorun/core": "0.28.0-beta"
   },
   "devDependencies": {
     "@earendil-works/pi-ai": "1.2.0",
@@ -46,7 +46,7 @@
     "nylo": "dist/nylo.js"
   },
   "nylorun": {
-    "runtime": "0.31.0-beta",
-    "studio": "0.31.1-beta"
+    "runtime": "0.32.0-beta",
+    "studio": "0.32.0-beta"
   }
 }