clavarium 0.2.366-next.1 → 0.2.368-next.1

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "clavarium",
-  "version": "0.2.366-next.1",
+  "version": "0.2.368-next.1",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "clavarium",
-      "version": "0.2.366-next.1",
+      "version": "0.2.368-next.1",
       "license": "MIT",
       "dependencies": {
         "@xterm/addon-fit": "^0.11.0",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clavarium",
-  "version": "0.2.366-next.1",
+  "version": "0.2.368-next.1",
   "license": "MIT",
   "type": "module",
   "description": "A conversation is a VM with a terminal in it. Everything else is a folder.",

package/server/api.mjs

@@ -94,6 +94,7 @@
  *   GET  /api/rooms                         the rooms (#268): [{id, name, host, members: [{id, kind, name, ref, host?}], unread, last, thinking: [names]}]
  *   POST /api/rooms                         {name, conversations: [names], boxes: [ids], host?}: a new room
  *   POST /api/rooms/<id>                    {name?, host?, add?: {conversations, boxes}, remove?: [member ids]}
+ *                                           quiet?: true/false (muted in the list: no dot, at the bottom)
  *   POST /api/rooms/<id>/remove             the room and its thread
  *   POST /api/rooms/<id>/give               {asset, rights, shared?}: the same right given to each AI of it, its own
  *                                           conversation's -> {asset, rights, given: [{conversation, ok, kept?, error?}]}
@@ -699,6 +700,8 @@ export async function handleApi(request, response, conversations, headers, resou
             if (access !== 'write') gitKeeper?.forgetAttachment(name, conversation);
             await resources.attach(conversation, name, access);
             retell(conversation);
+            /* Newly attached: its links looked at (and its mounts), not waited for. */
+            if (access !== 'none') void health?.check?.(conversation, { asked: true })?.catch?.(() => {});
         };
         const handSecret = async (conversation, name, attached) => {
             if (!conversations.list().some((c) => c.name === conversation)) throw new Refusal(404, 'No such conversation.');
@@ -867,6 +870,13 @@ export async function handleApi(request, response, conversations, headers, resou
             if (!conversations.list().some((c) => c.name === conversation)) throw new Refusal(404, 'No such conversation.');
             return send(200, health.markSeen(conversation)), true;
         }
+        /* "Check shared folders": each mounted and readable (put back when loose), each link the share cannot serve (health.mjs). */
+        const foldersOf = /^\/api\/conversations\/([^/]+)\/folders\/check$/.exec(pathname);
+        if (foldersOf && health) {
+            const conversation = decodeURIComponent(foldersOf[1]);
+            if (!conversations.list().some((c) => c.name === conversation)) throw new Refusal(404, 'No such conversation.');
+            return send(200, await health.checkFolders(conversation)), true;
+        }
         const machine = /^\/api\/conversations\/([^/]+)\/(restart|machine|health)$/.exec(pathname);
         if (machine) {
             const conversation = decodeURIComponent(machine[1]);

package/server/health.mjs

@@ -24,6 +24,7 @@
    should be mounted; they are passed as arguments, never parsed by the
    shell. It prints one fact per line; the server reads only these lines. */
 import { SHARING_STEP } from './vm.mjs';
+import { WHY } from './linkguard.mjs';
 
 /* How long installing the shared-folder helper in a machine may take (it comes from the snap store). */
 export const SHARING_MS = 180_000;
@@ -123,13 +124,16 @@ export function judge(record) {
         for (const { path, why } of record.failed ?? []) add('bad', 'mount', `failed:${path}`, `${path} is not reachable in the machine and could not be mounted again${why ? `: ${why}` : ''}.`);
         for (const path of record.missing ?? []) if (!(record.failed ?? []).some((f) => f.path === path)) add('warn', 'mount', `missing:${path}`, `${path} is not reachable in the machine.`);
     }
+    /* Links its folders hold that the share cannot serve (linkguard.mjs): looked at on this server, whatever its machine does. */
+    for (const l of record.links?.removed ?? []) add('info', 'link', `link-removed:${l.folder}/${l.path}`, `/resources/${l.folder}/${l.path} was a broken link (${WHY[l.kind] ?? l.kind}): it was removed on the server, what it pointed to left as it was.`);
+    for (const l of record.links?.found ?? []) add('warn', 'link', `link:${l.folder}/${l.path}`, `/resources/${l.folder}/${l.path} is a link its machine cannot follow (${WHY[l.kind] ?? l.kind}): make it point inside the folder, or remove it.`);
     const order = ['ok', 'info', 'warn', 'bad'];
     const level = problems.reduce((worst, p) => (order.indexOf(p.level) > order.indexOf(worst) ? p.level : worst), 'ok');
     return { level, problems: problems.slice(0, PROBLEMS_MAX).map((p) => ({ ...p, text: p.text.slice(0, TEXT_MAX) })) };
 }
 
 export class Health {
-    #vms; #conversations; #resources; #records = new Map(); #running = new Map(); #quiet = new Map(); #settleMs; #probeMs; #lookMs; #seen;
+    #vms; #conversations; #resources; #records = new Map(); #running = new Map(); #quiet = new Map(); #settleMs; #probeMs; #lookMs; #seen; #links;
     /* Set by the server: told each judgment (the chat of a conversation says what is wrong: talk.mjs). */
     judged = () => {};
     /* Set by the server: told a conversation is forgotten (what else is kept of its machine goes too). */
@@ -139,8 +143,9 @@ export class Health {
        again (a machine that has just started may still be mounting it).
        `lookMs`: how long the clock waits for one conversation's look. */
     /* `seen`: a store of the problems its owner marked seen ("Seen"), by conversation. */
-    constructor({ vms, conversations, resources, settleMs = 5000, probeMs = PROBE_MS, lookMs = LOOK_MS, seen = null }) {
-        this.#seen = seen;
+    /* `links`: the guard of links its folders cannot serve (linkguard.mjs), or null. */
+    constructor({ vms, conversations, resources, settleMs = 5000, probeMs = PROBE_MS, lookMs = LOOK_MS, seen = null, links = null }) {
+        this.#seen = seen; this.#links = links;
         this.#vms = vms; this.#conversations = conversations; this.#resources = resources; this.#settleMs = settleMs; this.#probeMs = probeMs; this.#lookMs = lookMs;
     }
 
@@ -217,13 +222,45 @@ export class Health {
                 }
             }
         }
+        const links = await this.#lookLinks(name, asked);
         return this.#keep(name, {
             at, state, answering: true, memory: facts.memory, oomKills: facts.oomKills ?? 0, ...(facts.oomKinds ? { oomKinds: facts.oomKinds } : {}), disks: facts.disks,
-            missing: loose(), ...(remounted.length ? { remounted } : {}), ...(failed.length ? { failed } : {}),
+            paths, missing: loose(), ...(remounted.length ? { remounted } : {}), ...(failed.length ? { failed } : {}), ...(links ? { links } : {}),
             /* What was put back stays said until a later look finds nothing to put back. */
         });
     }
 
+    /* Its folders' links, bounded (linkguard.mjs); never what holds up a look. */
+    async #lookLinks(name, force) {
+        if (!this.#links) return null;
+        return this.#links.check(name, { force }).catch(() => null);
+    }
+
+    /* "CHECK SHARED FOLDERS", asked by its owner: the same looks, now -- each
+       folder mounted and readable (put back when loose), each link the share
+       cannot serve -- and what was found or done, one item each. A machine
+       that does not run is not woken: only its folders' links are looked at. */
+    async checkFolders(name) {
+        const record = await this.check(name, { asked: true });
+        if (!record) return null;
+        let links = record.links;
+        if (!links && this.#links) links = await this.#links.check(name, { force: true }).catch(() => null);
+        const items = [];
+        if (record.state === 'Running' && record.answering === true) {
+            const failed = new Map((record.failed ?? []).map((f) => [f.path, f.why]));
+            for (const path of record.paths ?? []) {
+                if (failed.has(path)) items.push({ kind: 'mount-failed', path, why: failed.get(path) });
+                else if ((record.remounted ?? []).includes(path)) items.push({ kind: 'mount-remounted', path });
+                else if ((record.missing ?? []).includes(path)) items.push({ kind: 'mount-missing', path });
+                else items.push({ kind: 'mount-ok', path });
+            }
+        } else items.push({ kind: 'machine-off', state: record.state ?? null });
+        for (const l of links?.removed ?? []) items.push({ kind: 'link-removed', folder: l.folder, path: l.path, why: l.kind });
+        for (const l of links?.found ?? []) items.push({ kind: 'link-found', folder: l.folder, path: l.path, why: l.kind });
+        for (const c of links?.cut ?? []) items.push({ kind: 'links-cut', folder: c.folder, why: c.why });
+        return { at: record.at, items, health: this.of(name) };
+    }
+
     async #probe(name, paths) {
         /* Its output is the agent's: not more than a few pages of it are even taken in. */
         const r = await this.#vms.exec(name, ['sh', '-c', PROBE, PROBE_NAME, ...paths], { timeoutMs: this.#probeMs, maxBytes: PROBE_BYTES * 4 }).catch(() => ({ code: 1, stdout: '' }));

package/server/linkguard.mjs

@@ -0,0 +1,191 @@
+/* LINKS A SHARED FOLDER CANNOT SERVE, found on the server and, where it is
+ * safe, taken out.
+ *
+ * WHY. A folder is shown in a machine by the VM manager's own file server
+ * (multipass: sshfs in the machine, its SFTP server on this host). That
+ * server, not the machine, decides; root in the machine counts for nothing.
+ * It judges a link BY ITS TARGET: the target must lie in the folder and
+ * belong to the account the folder is mapped from (`-u`/`-g` of the mount).
+ * A link whose target is missing, loops, or lies elsewhere on this host has
+ * no such owner: reading it, renaming it and often removing it are refused
+ * ("Permission denied"), and what it says of it is nonsense ("Value too
+ * large"). Seen 07-11: app/node_modules made a link by a worktree, then
+ * committed, in a read-write folder its machine could not repair.
+ *
+ * WHAT IS DONE, here, where the folder is plain files:
+ *   - a link named node_modules that the share cannot serve: removed (the
+ *     link, never what it points to); its tool is told it may install its
+ *     dependencies again;
+ *   - a link that loops, or points nowhere outside the folder: removed;
+ *   - any other (an absolute target, one outside the folder, one inside it
+ *     not there yet): said, and left.
+ *
+ * BOUNDED: a few levels deep, so many entries, so long; .git and real
+ * node_modules folders are not walked. A folder looked at recently is not
+ * looked at again unless asked (`force`).
+ */
+import { opendir, lstat, readlink, realpath, unlink } from 'node:fs/promises';
+import { dirname, isAbsolute, join, relative, resolve, sep } from 'node:path';
+
+export const CAPS = Object.freeze({ depth: 6, entries: 20_000, ms: 2_000, links: 50 });
+/* A folder is looked at again by the clock this often at most. */
+export const EVERY_MS = 10 * 60_000;
+/* A removal is said to a conversation once a day at most, should the link come back. */
+export const SAY_AGAIN_MS = 24 * 60 * 60_000;
+const NOT_WALKED = new Set(['.git', 'node_modules']);
+export const KINDS = ['loop', 'dangling', 'absolute', 'outside'];
+
+const inside = (root, path) => path === root || path.startsWith(`${root}${sep}`);
+
+/* What is wrong with the link at `full` (under the real path `root`), or null. */
+export async function judgeLink(root, full) {
+    let target;
+    try { target = await readlink(full); } catch { return null; }
+    let real;
+    try { real = await realpath(full); } catch (error) {
+        if (error.code === 'ELOOP') return { kind: 'loop', target };
+        if (error.code === 'ENOENT' || error.code === 'ENOTDIR') {
+            /* Where it would point, as written: outside the folder, it points nowhere the share serves. */
+            const aim = isAbsolute(target) ? target : resolve(dirname(full), target);
+            return { kind: 'dangling', target, escapes: isAbsolute(target) || !inside(root, aim) };
+        }
+        return { kind: 'outside', target };
+    }
+    /* An absolute target is a path of THIS host: in the machine it names something else, or nothing. */
+    if (isAbsolute(target)) return { kind: 'absolute', target };
+    if (!inside(root, real)) return { kind: 'outside', target };
+    return null;
+}
+
+/* Taken out without asking: a node_modules link, a loop, a link to nowhere outside the folder. */
+export function removable(link) {
+    const base = link.path.split('/').pop();
+    return base === 'node_modules' || link.kind === 'loop' || (link.kind === 'dangling' && link.escapes === true);
+}
+
+/* The links of one folder the share cannot serve: { links: [{ path, kind, target }], cut }.
+   `cut`: why the look stopped early ('depth', 'entries', 'time', 'links'), or null. */
+export async function scanFolder(folder, caps = CAPS, now = () => Date.now()) {
+    const root = await realpath(folder);
+    const until = now() + caps.ms;
+    const links = []; let entries = 0; let cut = null; let deeper = false;
+    const stack = [{ dir: root, depth: 0 }];
+    while (stack.length > 0 && !cut) {
+        const { dir, depth } = stack.pop();
+        let handle;
+        /* A folder swapped for a link since it was listed is not followed out. */
+        try { if (dir !== root && (await realpath(dir)) !== dir) continue; handle = await opendir(dir); } catch { continue; }
+        try {
+            for (let entry = await handle.read(); entry !== null; entry = await handle.read()) {
+                if (++entries > caps.entries) { cut = 'entries'; break; }
+                if (now() > until) { cut = 'time'; break; }
+                const full = join(dir, entry.name);
+                if (entry.isSymbolicLink()) {
+                    const wrong = await judgeLink(root, full);
+                    if (!wrong) continue;
+                    if (links.length >= caps.links) { cut = 'links'; break; }
+                    links.push({ path: relative(root, full).split(sep).join('/'), ...wrong });
+                } else if (entry.isDirectory() && !NOT_WALKED.has(entry.name)) {
+                    if (depth + 1 < caps.depth) stack.push({ dir: full, depth: depth + 1 });
+                    else deeper = true;
+                }
+            }
+        } finally { await handle.close().catch(() => {}); }
+    }
+    return { links, cut: cut ?? (deeper ? 'depth' : null) };
+}
+
+/* Removes the link `path` of `folder`: '' when done, or why not. Only a link,
+   and only where its folder is still the one walked (a folder on the way
+   swapped for a link meanwhile is not followed). */
+export async function removeLink(folder, path) {
+    const root = await realpath(folder);
+    const full = join(root, ...path.split('/'));
+    if (!inside(root, full) || full === root) return 'not in the folder';
+    try {
+        if ((await realpath(dirname(full))) !== dirname(full)) return 'its folder moved';
+        if (!(await lstat(full)).isSymbolicLink()) return 'not a link any more';
+        await unlink(full);
+        return '';
+    } catch (error) { return error.code === 'ENOENT' ? 'already gone' : error.message; }
+}
+
+/* THE GUARD, for each conversation's attached folders.
+     `resources`: of(conversation) [{ name }], folder(name), attachedTo(name) [conversation]
+     `removed(conversation, { folder, path, kind, target })`: told once per removal, to each
+     conversation the folder is attached to (its chat, its tool: main.mjs). */
+export class LinkGuard {
+    #resources; #caps; #everyMs; #now; #last = new Map(); #going = new Map(); #said = new Map();
+    removed = () => {};
+    constructor({ resources, caps = CAPS, everyMs = EVERY_MS, now = () => Date.now() }) {
+        this.#resources = resources; this.#caps = caps; this.#everyMs = everyMs; this.#now = now;
+    }
+
+    /* Looks at the folders of `conversation`: { found, removed, cut }, each with its folder's name. */
+    async check(conversation, { force = false } = {}) {
+        const out = { found: [], removed: [], cut: [] };
+        for (const { name } of this.#resources.of(conversation)) {
+            /* A mailbox is written by this server alone. */
+            if (this.#resources.get?.(name)?.type === 'mailbox') continue;
+            const r = await this.#folder(name, force).catch(() => null);
+            if (!r) continue;
+            out.found.push(...r.found.map((l) => ({ folder: name, ...l })));
+            out.removed.push(...r.removed.map((l) => ({ folder: name, ...l })));
+            if (r.cut) out.cut.push({ folder: name, why: r.cut });
+        }
+        return out;
+    }
+
+    /* One folder, one look at a time (two conversations may share it). */
+    #folder(name, force) {
+        const last = this.#last.get(name);
+        if (!force && last && this.#now() - last.at < this.#everyMs) return Promise.resolve({ ...last.result, removed: [] });
+        const going = this.#going.get(name);
+        if (going) return going;
+        const look = this.#look(name).finally(() => this.#going.delete(name));
+        this.#going.set(name, look);
+        return look;
+    }
+
+    async #look(name) {
+        const folder = this.#resources.folder(name);
+        const { links, cut } = await scanFolder(folder, this.#caps, this.#now);
+        const found = []; const removed = [];
+        for (const link of links) {
+            if (removable(link) && (await removeLink(folder, link.path)) === '') removed.push(link);
+            else found.push(link);
+        }
+        const result = { found, removed, cut };
+        this.#last.set(name, { at: this.#now(), result: { found, removed: [], cut } });
+        for (const link of removed) this.#tell(name, link);
+        return result;
+    }
+
+    #tell(name, link) {
+        const conversations = this.#resources.attachedTo?.(name) ?? [];
+        for (const conversation of conversations) {
+            const key = `${conversation}\0${name}\0${link.path}`;
+            if (this.#now() - (this.#said.get(key) ?? -Infinity) < SAY_AGAIN_MS) continue;
+            this.#said.set(key, this.#now());
+            try { this.removed(conversation, { folder: name, ...link }); } catch { /* told, nothing more */ }
+        }
+    }
+
+    forget(name) { this.#last.delete(name); }
+}
+
+/* What it says, in French, in the conversation's chat (one line). */
+export function removedLine({ folder, path }) {
+    const where = path.includes('/') ? ` (${path})` : '';
+    return path.split('/').pop() === 'node_modules'
+        ? `Un lien node_modules cassé dans ${folder}${where} a été retiré ; ses dépendances sont à réinstaller.`
+        : `Un lien cassé dans ${folder} (${path}) a été retiré : il ne menait nulle part.`;
+}
+/* What its tool is told, when the link was a node_modules (in English, as its other lines). */
+export function toolLine({ folder, path }) {
+    const dir = path.split('/').slice(0, -1).join('/');
+    const at = `/resources/${folder}${dir ? `/${dir}` : ''}`;
+    return `Clavarium: ${at}/node_modules was a link your machine could not use; it was removed on the server (what it pointed to was left as it was). You may install the dependencies again now: run npm ci (or npm install) in ${at}. If your rules forbid npm install, ask the operator to allow it.`;
+}
+/* Why a link is said, in a few words. */
+export const WHY = Object.freeze({ loop: 'it loops', dangling: 'its target is missing', absolute: 'its target is an absolute path of the server', outside: 'its target is outside the folder' });

package/server/main.mjs

@@ -59,6 +59,7 @@ import { GitKeeper } from './gitkeeper.mjs';
 import { GitRunner } from './gitrunner.mjs';
 import { Shelf } from './shelf.mjs';
 import { Health } from './health.mjs';
+import { LinkGuard, removedLine, toolLine } from './linkguard.mjs';
 import { Setup } from './setup.mjs';
 import { Capacity } from './capacity.mjs';
 import { packageFile, PARLEY } from './parley.mjs';
@@ -575,7 +576,17 @@ export async function startHome({ port, host, dataDir, mntDir = dataDir, gitRese
         }
     }, 15_000); restartTimer.unref?.();
     /* The health of each machine, and folders that came loose put back: see health.mjs. */
-    const health = new Health({ vms, conversations: all, resources: folders, seen: new Store(`${dataDir}/health-seen.json`), ...(healthSettleMs === undefined ? {} : { settleMs: healthSettleMs }) });
+    /* Links its folders hold that the share cannot serve: removed where safe, said once (linkguard.mjs). */
+    const linkGuard = typeof folders.attachedTo === 'function' ? new LinkGuard({ resources: folders }) : null;
+    if (linkGuard) linkGuard.removed = (name, link) => {
+        try { talk.event(name, { kind: 'machine-ok', text: removedLine(link), topic: 'Machine', brief: 'Shared folder' }); } catch { /* its chat is off */ }
+        if (link.path.split('/').pop() !== 'node_modules') return;
+        /* Its tool told it may install them again: through its docket where its chat is on, else typed to its agent. */
+        const line = toolLine(link);
+        try { if (dockets.on(name)) { dockets.post(name, { kind: 'shared-folder', text: line, data: { folder: link.folder, path: link.path } }); return; } } catch { /* typed instead */ }
+        if (all.list().find((c) => c.name === name)?.ai === true) void wakeups.say(name, line).catch(() => {});
+    };
+    const health = new Health({ vms, conversations: all, resources: folders, links: linkGuard, seen: new Store(`${dataDir}/health-seen.json`), ...(healthSettleMs === undefined ? {} : { settleMs: healthSettleMs }) });
     const stopHealth = health.start(healthEveryMs);
     /* What is wrong with its machine is said in its chat too, where it happened. */
     /* And what its owner chose that it does on top (healthreact.mjs): its agent told, or a command run. */
@@ -589,6 +600,8 @@ export async function startHome({ port, host, dataDir, mntDir = dataDir, gitRese
     const problemsSaid = new Map();
     health.judged = (name, record) => {
         talk.machine(name, record); void reacting.judged(name, record).catch(() => {});
+        /* A folder that came loose and was put back: said once, in its chat (the look that put it back). */
+        for (const path of record?.remounted ?? []) { try { talk.event(name, { kind: 'machine-ok', text: `Le dossier ${path} s'était détaché de la machine : il a été remonté.`, topic: 'Machine', brief: 'Shared folder' }); } catch { /* its chat is off */ } }
         try { healthDocket.judged(name, record); } catch { /* its docket: nothing more */ }
         const now = (record?.problems ?? []).filter((x) => x.level === 'bad' || (x.level === 'warn' && ['memory', 'disk'].includes(x.kind)));
         const before = problemsSaid.get(name) ?? new Set();

package/server/resources.mjs

@@ -140,6 +140,12 @@ export class Resources {
     }
     get(name) { return this.#store.get(name); }
 
+    /* The conversations a folder is attached to. */
+    attachedTo(name) {
+        const resource = this.#store.get(name);
+        return resource ? Object.keys(this.#attachments(resource)) : [];
+    }
+
     /* What one conversation has attached: [{ name, access }]. */
     of(conversation) {
         return this.#store.all().map((r) => ({ name: r.name, access: this.#attachments(r)[conversation] })).filter((r) => r.access !== undefined);

package/server/rooms.mjs

@@ -100,7 +100,7 @@ export class Rooms {
        in its row of the list and on its bar, « Hugo réfléchit… » in its thread. */
     #thinkingOf(id, members) { return [...(this.#thinking.get(id) ?? new Map()).entries()].filter(([, v]) => Date.now() - v.at < THINKING_MS).map(([mid]) => members.find((m) => m.id === mid)?.name).filter(Boolean); }
     #doingOf(id, members) { return [...(this.#thinking.get(id) ?? new Map()).entries()].filter(([, v]) => v.text && Date.now() - v.at < THINKING_MS).map(([mid, v]) => ({ name: members.find((m) => m.id === mid)?.name, text: v.text })).filter((x) => x.name); }
-    list() { return this.#all().map((r) => { const members = this.#shown(r); return { id: r.id, name: r.name, host: r.host, members, at: r.at, unread: this.#unread(r), last: this.#last(r), thinking: this.#thinkingOf(r.id, members) }; }); }
+    list() { return this.#all().map((r) => { const members = this.#shown(r); return { id: r.id, name: r.name, host: r.host, members, at: r.at, unread: this.#unread(r), last: this.#last(r), thinking: this.#thinkingOf(r.id, members), ...(r.quiet ? { quiet: true } : {}) }; }); }
     /* ITS AIs, as conversations (06-11): the names of the conversations of its AI members that are there now --
        never a box, never the person, never one taken out of the room. What « give to all its AIs » gives to. */
     ais(id) { return this.#shown(this.#find(id)).filter((m) => m.kind === 'ai').map((m) => m.ref); }
@@ -139,10 +139,11 @@ export class Rooms {
         if (new Set(names).size !== names.length) throw new Refusal(409, 'Two members of a room cannot have the same name: rename one first.');
         if (room.members.length > MEMBERS_MAX) throw new Refusal(409, `${MEMBERS_MAX} members at most.`);
     }
-    /* Its name, its host, members added or taken away. */
-    change(id, { name, host, add = {}, remove = [] } = {}) {
+    /* Its name, its host, members added or taken away; `quiet` (07-11, the tidy-up): muted in the list, or not. */
+    change(id, { name, host, add = {}, remove = [], quiet } = {}) {
         const list = this.#all(); const room = list.find((r) => r.id === id);
         if (!room) throw new Refusal(404, 'No such room.');
+        if (quiet !== undefined) { if (quiet === true) room.quiet = true; else delete room.quiet; }
         if (name !== undefined) {
             const n = nameOf(name); if (!n) throw new Refusal(400, 'Give the room a name.');
             if (list.some((r) => r.id !== id && r.name.toLowerCase() === n.toLowerCase())) throw new Refusal(409, 'A room has that name already.');

package/server/settingswords.mjs

@@ -13,6 +13,13 @@ export const SETTINGS_WORDS_FR = {
     'set-ch-s-usage': 'Usage', 'set-ch-s-backup': 'Sauvegarde', 'set-ch-s-advanced': 'Avancé',
     'set-check-updates': 'Chercher une mise à jour', 'set-activity': 'Activité', 'set-restart-dots': 'Redémarrer…', 'set-terminal': 'Terminal',
     'set-search': 'Chercher', 'set-why': 'Pourquoi',
+    /* Diagnostics › « Vérifier les dossiers partagés » (health.mjs, linkguard.mjs). */
+    'set-check-folders': 'Vérifier les dossiers partagés', 'set-looking': 'Vérification…',
+    'set-fold-ok': '{path} : monté, lisible', 'set-fold-remounted': '{path} : détaché, remonté', 'set-fold-missing': '{path} : inaccessible',
+    'set-fold-failed': '{path} : inaccessible, pas remonté', 'set-fold-link-removed': '{path} : lien cassé retiré ({why})',
+    'set-fold-link-found': '{path} : lien inutilisable ({why})', 'set-fold-cut': '{path} : trop gros, vérifié en partie',
+    'set-fold-off': 'Machine arrêtée : liens seuls vérifiés', 'set-fold-none': 'Aucun dossier partagé',
+    'set-link-loop': 'boucle', 'set-link-dangling': 'cible absente', 'set-link-absolute': 'cible en chemin absolu', 'set-link-outside': 'cible hors du dossier',
     'set-memory': 'Mémoire', 'set-disk': 'Disque', 'set-cpu': 'Processeur',
     'set-free-of': '{free} libres sur {total}', 'set-left-of': '{free} restants sur {total}', 'set-highest': 'au plus {n} % en 1 h',
     'set-core': '1 cœur', 'set-cores': '{n} cœurs',
@@ -33,7 +40,7 @@ export const SETTINGS_WORDS_FR = {
     'set-dict-backup': 'Secours en service', 'set-dict-expired': 'Clé expirée', 'set-dict-with-backup': 'avec secours', 'set-dict-server': 'réglée sur le serveur',
     'set-attached': '{n} joints', 'set-secret': '1 secret', 'set-secrets': '{n} secrets', 'set-offline': 'hors ligne',
     'set-device': '1 appareil', 'set-devices': '{n} appareils', 'set-no-device': 'Aucun appareil', 'set-chat': 'Chat',
-    'set-wakeups-on': '{on} sur {n} actifs', 'set-asleep': 'Endormie', 'set-not-looked': 'Pas encore regardée',
+    'set-wakeups-on': '{on} sur {n} actifs', 'set-asleep': 'En veille', 'set-not-looked': 'Pas encore regardée',
     'set-running-well': 'En marche · rien d\'anormal', 'set-conv-advanced': 'Archiver · remettre à neuf · supprimer',
     /* New asset, one box (05-11, step 3): one verb per gesture -- Créer, Attacher, Terminé. */
     'set-na-new': 'Nouvel asset', 'set-na-attach': 'Attacher', 'set-na-there': 'Déjà là', 'set-na-or-new': 'ou un nouveau',
@@ -109,11 +116,15 @@ export const SETTINGS_WORDS_FR = {
     'set-list-not-filed': 'Sans groupe', 'set-list-asks': 'vous demande', 'set-list-waits': 'vous attend',
     'set-list-asks-for': 'le répondeur vous demande', 'set-list-answered': 'a répondu à votre place',
     'set-list-wakeup': '1 réveil', 'set-list-wakeups': '{n} réveils', 'set-list-hidden': 'cachée',
-    'set-list-asleep': 'endormie, se réveille à l\'ouverture', 'set-list-starting': 'démarre', 'set-list-restarting': 'redémarre',
+    'set-list-asleep': 'en veille', 'set-list-starting': 'démarre', 'set-list-restarting': 'redémarre',
     'set-list-moving': 'déplace son travail', 'set-list-failed': 'en échec', 'set-list-you': 'Vous : {text}',
     'set-list-fewer': 'En montrer moins', 'set-list-more': 'En montrer {n} de plus',
     'set-list-hide-hidden': 'Masquer les {n} cachées', 'set-list-n-hidden': '{n} cachées',
     'set-list-tip': 'Rangez-les en groupes : Réglages, Groupe.',
+    'set-idle-h': 'rien depuis {n} h', 'set-idle-d': 'rien depuis {n} j', 'set-idle-w': 'rien depuis {n} sem.', 'set-idle-mo': 'rien depuis {n} mois',
+    'set-tidy-open': 'Faire le ménage ({n})', 'set-tidy-title': 'Mettre en veille ?', 'set-tidy-hint': 'Rien depuis 12 h ou plus.',
+    'set-tidy-go': 'Mettre en veille ({n})', 'set-close': 'Fermer',
+    'set-asleep-page': 'En veille. Elle reprend quand vous la réveillez.', 'set-wake-it': 'Réveiller',
     'set-as-k-git': 'Dépôts git', 'set-as-k-folder': 'Dossiers', 'set-as-k-mailbox': 'Boîtes mail', 'set-as-k-agenda': 'Agendas',
     'set-as-k-contacts': 'Contacts', 'set-as-k-secret': 'Secrets', 'set-as-k-list': 'Classeurs', 'set-as-k-acces': 'Accès',
     'set-as-kind-folder': 'dossier', 'set-as-kind-git': 'dépôt', 'set-as-kind-mailbox': 'boîte mail',
@@ -134,12 +145,14 @@ export const SETTINGS_WORDS_FR = {
     'set-files-read-only': 'Lecture seule : rien ne peut y être changé.',
     'set-this-conv': 'Cette conversation · {name}', 'set-ask-first': 'Demander avant d\'agir',
     'set-online': 'En ligne', 'set-offline-btn': 'Hors ligne', 'set-sleep': 'Endormir',
-    'set-room-name': 'Nom', 'set-room-host': 'Accueille le salon', 'set-room-host-what': 'répond, ou passe le message',
-    'set-room-host-pick': 'Choisissez ci-dessous : « Accueille »', 'set-room-welcomes': 'Accueille', 'set-room-ais': 'Ses IA',
-    'set-room-in': '{n} dans le salon', 'set-room-find': 'Chercher une conversation', 'set-room-boxes': 'Boîtiers vocaux',
+    'set-room-name': 'Nom', 'set-room-welcomes': 'Accueille', 'set-room-ais': 'Ses IA',
+    'set-room-find': 'Chercher une conversation', 'set-room-boxes': 'Boîtiers vocaux',
     'set-room-remove': 'Supprimer le salon', 'set-room-remove-what': 'Le fil part · les IA et boîtiers restent',
     'set-room-remove-dots': 'Supprimer…', 'set-room-remove-yes': 'Supprimer {name}', 'set-room-keep': 'Garder',
-    'set-room-cancel': 'Annuler', 'set-room-save': 'Enregistrer', 'set-room-create': 'Créer', 'set-room-new': 'Nouveau salon',
+    'set-room-create': 'Créer', 'set-room-new': 'Nouveau salon',
+    /* A room's settings as every settings page (07-11): each change saved at once, said a moment in the bar. */
+    'set-room-saved': 'Enregistré', 'set-room-settings-of': '{name} · Réglages', 'set-room-of': '{n} sur {t}',
+    'set-room-host-how': 'Touchez une autre IA du salon pour la déplacer',
     'set-room-people': 'Personnes', 'set-room-ais-of': 'IA', 'set-room-boxes-of': 'Boîtiers', 'set-room-host-mark': 'accueille',
     'set-room-n-person': '1 personne', 'set-room-n-people': '{n} personnes', 'set-room-n-ai': '1 IA', 'set-room-n-ais': '{n} IA',
     'set-room-n-box': '1 boîtier', 'set-room-n-boxes': '{n} boîtiers',

package/server/talk.mjs

@@ -653,10 +653,11 @@ export class Talk {
             tone: fresh.some((p) => p.level === 'bad') ? 'bad' : 'warn',
             topic: 'Machine',
             /* Its name on the one line a problem is in the simple view (Parley, 03-11). */
-            brief: fresh.some((p) => p.kind === 'memory' || /^oom:|^memory/.test(p.key ?? '')) ? 'Out of memory' : fresh.every((p) => p.kind === 'disk') ? 'Disk almost full' : 'Machine problem',
+            brief: fresh.some((p) => p.kind === 'memory' || /^oom:|^memory/.test(p.key ?? '')) ? 'Out of memory' : fresh.every((p) => p.kind === 'disk') ? 'Disk almost full' : fresh.every((p) => p.kind === 'link') ? 'Shared folder' : 'Machine problem',
             /* What can be done: a disk short of room is looked at (what takes it) or made larger --
                a restart frees nothing; otherwise more memory where memory is short, a restart, its terminal. */
-            actions: [...(fresh.every((p) => p.kind === 'disk') ? ['room', 'disk'] : [...(fresh.some((p) => p.kind === 'memory') ? ['memory'] : []), 'restart', 'terminal']), 'seen'],
+            /* A link in a folder (linkguard.mjs) is the folder's business: a restart changes nothing. */
+            actions: [...(fresh.every((p) => p.kind === 'link') ? [] : fresh.every((p) => p.kind === 'disk') ? ['room', 'disk'] : [...(fresh.some((p) => p.kind === 'memory') ? ['memory'] : []), 'restart', 'terminal']), 'seen'],
         });
     }