@platless/axom-cli 0.5.9 → 0.6.52

package/dist/workstation/service/systemd.js

@@ -35,6 +35,7 @@ Type=simple
 WorkingDirectory=${systemdToken(context.homeDir)}
 ${environment('HOME', context.homeDir)}
 ${environment('AXOM_WORKSTATION_CONFIG_DIR', context.configDir)}
+${environment('AXOM_WORKSTATION_RUNTIME', 'device-v2')}
 ${environment('AXOM_WORKSTATION_NPM_PATH', context.npmPath)}
 ${environment('AXOM_WORKSTATION_NPM_PREFIX', context.npmPrefix)}
 ${environment('PATH', context.pathEnv)}

package/dist/workstation/storageMetrics.js

@@ -0,0 +1,118 @@
+import { execFile } from 'node:child_process';
+import { statSync } from 'node:fs';
+import path from 'node:path';
+import { promisify } from 'node:util';
+const execFileAsync = promisify(execFile);
+const LOCAL_FILESYSTEMS = new Set([
+    'ext2', 'ext3', 'ext4', 'xfs', 'btrfs', 'zfs', 'f2fs', 'bcachefs',
+    'vfat', 'exfat', 'ntfs', 'ntfs3', 'fuseblk',
+]);
+export function linuxStoragePools(mounts) {
+    const pools = new Map();
+    for (const mount of mounts) {
+        if (!LOCAL_FILESYSTEMS.has(mount.fstype) || mount.options?.split(',').includes('ro'))
+            continue;
+        if (/^\/(?:boot|efi)(?:\/|$)/.test(mount.target))
+            continue;
+        const source = mount.source.split('[')[0];
+        const key = mount.fstype === 'zfs'
+            ? `zfs:${source.split('/')[0]}`
+            : mount.uuid ? `${mount.fstype}:${mount.uuid}` : `dev:${mount['maj:min']}`;
+        const existing = pools.get(key);
+        if (existing)
+            existing.paths.push(mount.target);
+        else
+            pools.set(key, { key, label: mount.label || source, paths: [mount.target] });
+    }
+    if (pools.size === 0) {
+        const root = mounts.find((mount) => mount.target === '/' && mount.fstype === 'overlay');
+        if (root)
+            pools.set('overlay:/', { key: 'overlay:/', label: 'Container storage', paths: ['/'] });
+    }
+    return [...pools.values()];
+}
+export function darwinStoragePools(disks, physicalDisks, containers) {
+    const physical = new Set(physicalDisks.flatMap((disk) => [disk.DeviceIdentifier, ...(disk.Partitions ?? []).map((part) => part.DeviceIdentifier)]));
+    const volumes = disks.flatMap((disk) => [disk, ...(disk.Partitions ?? []), ...(disk.APFSVolumes ?? [])]);
+    const pools = [];
+    for (const container of containers) {
+        if (!container.PhysicalStores.some((store) => physical.has(store.DeviceIdentifier)))
+            continue;
+        const userVolumes = container.Volumes.filter((volume) => volume.Roles.length === 0 || volume.Roles.includes('Data'));
+        userVolumes.sort((first, second) => Number(second.Roles.includes('Data')) - Number(first.Roles.includes('Data')));
+        const mounted = userVolumes.flatMap((volume) => {
+            const disk = volumes.find((candidate) => candidate.DeviceIdentifier === volume.DeviceIdentifier);
+            return disk?.MountPoint ? [{ name: volume.Name, mount: disk.MountPoint }] : [];
+        });
+        if (mounted.length === 0)
+            continue;
+        const system = container.Volumes.find((volume) => volume.Roles.includes('System'));
+        pools.push({
+            key: `apfs:${container.APFSContainerUUID}`,
+            label: system?.Name || mounted[0].name,
+            paths: mounted.map((volume) => volume.mount),
+        });
+    }
+    for (const volume of volumes) {
+        if (!physical.has(volume.DeviceIdentifier) || !volume.MountPoint)
+            continue;
+        if (!['Apple_HFS', 'Microsoft Basic Data', 'Windows_NTFS', 'DOS_FAT_32', 'DOS_FAT_16', 'ExFAT'].includes(volume.Content ?? ''))
+            continue;
+        pools.push({
+            key: `volume:${volume.VolumeUUID || volume.DiskUUID || volume.DeviceIdentifier}`,
+            label: volume.VolumeName || volume.MountPoint,
+            paths: [volume.MountPoint],
+        });
+    }
+    return pools;
+}
+async function diskutilJson(args) {
+    const { stdout } = await execFileAsync('/usr/sbin/diskutil', args, {
+        timeout: 5_000, maxBuffer: 4 * 1024 * 1024,
+    });
+    const json = await new Promise((resolve, reject) => {
+        const child = execFile('/usr/bin/plutil', ['-convert', 'json', '-o', '-', '-'], {
+            timeout: 2_000, maxBuffer: 4 * 1024 * 1024,
+        }, (error, output) => error ? reject(error) : resolve(output));
+        child.stdin?.on('error', reject);
+        child.stdin?.end(stdout);
+    });
+    return JSON.parse(json);
+}
+export async function discoverStoragePools(platform, workspaces) {
+    if (platform === 'linux') {
+        const { stdout } = await execFileAsync('findmnt', [
+            '--json', '--list', '--output', 'TARGET,SOURCE,FSTYPE,UUID,LABEL,MAJ:MIN,OPTIONS',
+        ], { timeout: 5_000, maxBuffer: 4 * 1024 * 1024, env: { ...process.env, LC_ALL: 'C' } });
+        const mounts = JSON.parse(stdout).filesystems;
+        return linuxStoragePools(mounts.filter((mount) => {
+            try {
+                return statSync(mount.target).isDirectory();
+            }
+            catch {
+                return false;
+            }
+        }));
+    }
+    if (platform === 'darwin') {
+        const [all, physical, apfs] = await Promise.all([
+            diskutilJson(['list', '-plist']),
+            diskutilJson(['list', '-plist', 'physical']),
+            diskutilJson(['apfs', 'list', '-plist']),
+        ]);
+        return darwinStoragePools(all.AllDisksAndPartitions, physical.AllDisksAndPartitions, apfs.Containers ?? []);
+    }
+    const pools = new Map();
+    for (const { cwd } of workspaces) {
+        try {
+            const key = `dev:${statSync(cwd).dev}`;
+            const existing = pools.get(key);
+            if (existing)
+                existing.paths.push(cwd);
+            else
+                pools.set(key, { key, label: path.parse(cwd).root, paths: [cwd] });
+        }
+        catch { }
+    }
+    return [...pools.values()];
+}

package/dist/workstation/systemMetrics.js

@@ -2,8 +2,8 @@ import { execFile } from 'node:child_process';
 import { createHash } from 'node:crypto';
 import { readFileSync, statfsSync, statSync } from 'node:fs';
 import os from 'node:os';
-import path from 'node:path';
 import { promisify } from 'node:util';
+import { discoverStoragePools } from './storageMetrics.js';
 const execFileAsync = promisify(execFile);
 export const STORAGE_TOPOLOGY_REFRESH_MS = 10 * 60 * 1000;
 function cpuTotals(cpus) {
@@ -36,45 +36,6 @@ function linuxMemoryPressure(readFile) {
 function stablePoolId(key) {
     return createHash('sha256').update(key).digest('hex').slice(0, 16);
 }
-async function defaultIdentifyStorage(platform, cwd, device) {
-    try {
-        if (platform === 'darwin') {
-            const mounted = await execFileAsync('/bin/df', ['-P', cwd], {
-                timeout: 1_000,
-                env: { ...process.env, LC_ALL: 'C' },
-            });
-            const mountFields = mounted.stdout.trim().split('\n').at(-1)?.trim().split(/\s+/) ?? [];
-            const mountPoint = mountFields.slice(5).join(' ') || path.parse(cwd).root;
-            const { stdout } = await execFileAsync('/usr/sbin/diskutil', ['info', mountPoint], {
-                timeout: 1_000,
-                env: { ...process.env, LC_ALL: 'C' },
-            });
-            const container = /^\s*APFS Container Reference:\s*(\S+)\s*$/m.exec(stdout)?.[1];
-            const volume = /^\s*Volume Name:\s*(.+?)\s*$/m.exec(stdout)?.[1];
-            return container
-                ? { key: `apfs:${container}`, label: `APFS Container ${container}` }
-                : { key: `dev:${device}`, label: volume };
-        }
-        if (platform === 'linux') {
-            const { stdout } = await execFileAsync('findmnt', ['-n', '-P', '-o', 'FSTYPE,SOURCE,UUID,LABEL,TARGET', '--target', cwd], {
-                timeout: 2_000,
-                env: { ...process.env, LC_ALL: 'C' },
-            });
-            const fields = Object.fromEntries([...stdout.matchAll(/(\w+)="([^"]*)"/g)].map((match) => [match[1], match[2]]));
-            if (fields.FSTYPE === 'btrfs' && fields.UUID)
-                return { key: `btrfs:${fields.UUID}`, label: fields.SOURCE };
-            if (fields.FSTYPE === 'zfs' && fields.SOURCE) {
-                const pool = fields.SOURCE.split('/')[0];
-                return { key: `zfs:${pool}`, label: pool };
-            }
-            return { key: `dev:${device}`, label: fields.LABEL || fields.TARGET || fields.SOURCE };
-        }
-    }
-    catch {
-        // Resource-pool recognition is best-effort. Device identity below is the conservative fallback.
-    }
-    return { key: `dev:${device}` };
-}
 async function defaultDarwinAvailableMemory() {
     try {
         const { stdout } = await execFileAsync('/usr/bin/vm_stat', [], { timeout: 2_000 });
@@ -216,7 +177,7 @@ export class SystemMetricsSampler {
         readFile: readFileSync,
         statfs: statfsSync,
         stat: statSync,
-        identifyStorage: (cwd, device) => defaultIdentifyStorage(process.platform, cwd, device),
+        discoverStorage: () => discoverStoragePools(process.platform, workspaces),
         darwinAvailableMemory: defaultDarwinAvailableMemory,
         darwinMemoryPressure: defaultDarwinMemoryPressure,
         probeGpus: () => defaultProbeGpus(process.platform),
@@ -234,6 +195,9 @@ export class SystemMetricsSampler {
             clearInterval(this.refreshTimer);
         this.refreshTimer = null;
     }
+    refreshWorkspaces() {
+        this.refreshTopologyInBackground();
+    }
     snapshot() {
         try {
             this.refreshDarwinMemoryInBackground();
@@ -261,20 +225,23 @@ export class SystemMetricsSampler {
                 : (this.deps.platform === 'darwin' ? this.darwinMemoryPressure : null);
             const pools = new Map();
             for (const pool of this.storage) {
-                try {
-                    const stats = this.deps.statfs(pool.cwd);
-                    const totalBytes = Number(stats.blocks) * Number(stats.bsize);
-                    const availableBytes = Number(stats.bavail) * Number(stats.bsize);
-                    pools.set(pool.key, {
-                        id: stablePoolId(pool.key),
-                        label: pool.label,
-                        workspaces: pool.workspaces,
-                        totalBytes,
-                        availableBytes,
-                    });
-                }
-                catch {
-                    // A removed/unmounted workspace must not suppress CPU and memory metrics.
+                for (const cwd of pool.paths) {
+                    try {
+                        if (String(this.deps.stat(cwd).dev) !== pool.devices[cwd])
+                            continue;
+                        const stats = this.deps.statfs(cwd);
+                        const totalBytes = Number(stats.blocks) * Number(stats.bsize);
+                        const availableBytes = Number(stats.bavail) * Number(stats.bsize);
+                        pools.set(pool.key, {
+                            id: stablePoolId(pool.key),
+                            label: pool.label,
+                            workspaces: pool.workspaces,
+                            totalBytes,
+                            availableBytes,
+                        });
+                        break;
+                    }
+                    catch { }
                 }
             }
             return {
@@ -338,43 +305,31 @@ export class SystemMetricsSampler {
         this.darwinMemoryPressure = pressure;
     }
     async refreshTopology() {
-        const candidates = this.workspaces.map(({ name, cwd }) => {
-            try {
-                this.deps.statfs(cwd);
-                const device = String(this.deps.stat(cwd).dev);
-                return { name, cwd, device };
-            }
-            catch {
-                return null;
-            }
-        }).filter((candidate) => candidate !== null);
-        const representatives = new Map();
-        candidates.forEach(({ cwd, device }) => {
-            if (!representatives.has(device))
-                representatives.set(device, { cwd, device });
-        });
-        const identities = new Map(await Promise.all([...representatives.values()].map(async ({ cwd, device }) => [
-            device,
-            await this.deps.identifyStorage(cwd, device).catch(() => null),
-        ])));
-        const identified = candidates.map(({ name, cwd, device }) => {
-            try {
-                const identity = identities.get(device);
-                const key = identity?.key ?? `dev:${device}`;
-                return { name, cwd, key, label: identity?.label || path.parse(cwd).root || cwd };
-            }
-            catch {
-                return null;
-            }
-        });
-        const grouped = new Map();
-        for (const entry of identified.filter((candidate) => candidate !== null)) {
-            const existing = grouped.get(entry.key);
-            if (existing)
-                existing.workspaces.push(entry.name);
-            else
-                grouped.set(entry.key, { cwd: entry.cwd, key: entry.key, label: entry.label, workspaces: [entry.name] });
+        try {
+            const pools = await this.deps.discoverStorage();
+            this.storage = pools.map((pool) => {
+                const devices = Object.fromEntries(pool.paths.flatMap((cwd) => {
+                    try {
+                        return [[cwd, String(this.deps.stat(cwd).dev)]];
+                    }
+                    catch {
+                        return [];
+                    }
+                }));
+                const poolDevices = new Set(Object.values(devices));
+                const workspaces = this.workspaces.filter(({ cwd }) => {
+                    try {
+                        return poolDevices.has(String(this.deps.stat(cwd).dev));
+                    }
+                    catch {
+                        return false;
+                    }
+                }).map(({ name }) => name);
+                return { ...pool, workspaces, devices };
+            });
+        }
+        catch {
+            return;
         }
-        this.storage = [...grouped.values()];
     }
 }

package/dist/workstation/toolchain.js

@@ -0,0 +1,94 @@
+import { execFile } from 'node:child_process';
+import path from 'node:path';
+const PROBE_TIMEOUT_MS = 10_000;
+const VERIFY_TIMEOUT_MS = 3_000;
+/** Interpreters rarely appear or vanish; a slow refresh keeps the heartbeat itself free of any spawning. */
+export const TOOLCHAIN_REFRESH_MS = 15 * 60_000;
+/**
+ * Shells whose `-lc` runs a POSIX-ish command string with `command -v` (fish ≥ 3 included). Any other shell (csh, tcsh,
+ * nu, pwsh, …) is not probed: its answer is unknown, never "missing".
+ */
+const PROBED_SHELLS = new Set(['sh', 'bash', 'zsh', 'dash', 'ksh', 'mksh', 'fish']);
+/** Separates the probe's answers; no leading `=` (zsh would expand a bare `=word`). */
+const SPLIT = 'AXOM-PROBE-SPLIT';
+const DONE = 'AXOM-PROBE-DONE';
+const NAMES = ['python3', 'python', 'node'];
+/**
+ * One `<shell> -lc` run of `command -v` for each interpreter, the way commands run on this workstation (exec spawns the
+ * same login shell), so a Python found only through the user's profile counts. Each answer is the last absolute-path
+ * line of its segment (a login profile may print its own lines first). Null = unknown: a shell we do not probe, a shell
+ * that could not run, or a run that did not reach its end marker.
+ */
+export async function probeToolchain(shell, env = process.env, options = {}) {
+    if (!PROBED_SHELLS.has(path.basename(shell)))
+        return null;
+    const script = [...NAMES.map((name) => `command -v ${name}`), `echo ${DONE}`].join(`; echo ${SPLIT}; `);
+    const stdout = await run(shell, ['-lc', script], env, PROBE_TIMEOUT_MS);
+    if (stdout === undefined)
+        return null;
+    const lines = stdout.split('\n').map((line) => line.trim());
+    const doneAt = lines.lastIndexOf(DONE);
+    if (doneAt < 0)
+        return null;
+    const segments = [[]];
+    for (const line of lines.slice(0, doneAt)) {
+        if (line === SPLIT)
+            segments.push([]);
+        else
+            segments[segments.length - 1].push(line);
+    }
+    // `command -v python3; echo SPLIT; …; echo SPLIT; echo DONE`: one segment per name, then an empty one. A login
+    // profile's own output lands in the first segment, before the answer, so each answer is its segment's last path.
+    if (segments.length !== NAMES.length + 1)
+        return null;
+    const answers = segments.slice(0, NAMES.length);
+    const found = (index) => [...answers[index]].reverse().find((line) => path.isAbsolute(line)) ?? null;
+    let python3 = found(0);
+    if (python3 === '/usr/bin/python3' && (options.platform ?? process.platform) === 'darwin') {
+        if (!(await (options.macStubRuns ?? macCommandLineToolsInstalled)()))
+            python3 = null;
+    }
+    return { python: python3 ?? found(1), node: found(2) };
+}
+async function macCommandLineToolsInstalled() {
+    return (await run('/usr/bin/xcode-select', ['-p'], process.env, VERIFY_TIMEOUT_MS, true)) !== undefined;
+}
+/** The command's stdout; undefined = it did not run, timed out, or (with [strict]) exited non-zero. */
+function run(file, args, env, timeout, strict = false) {
+    return new Promise((resolve) => {
+        execFile(file, args, { env, timeout, windowsHide: true }, (error, stdout) => {
+            const code = error?.code;
+            if (error && (strict || typeof code !== 'number')) {
+                resolve(undefined);
+                return;
+            }
+            resolve(String(stdout));
+        });
+    });
+}
+/** Holds the latest probe; the first answer arrives shortly after start, until then the heartbeat simply omits it. */
+export class ToolchainProbe {
+    shell;
+    env;
+    latest = null;
+    timer;
+    constructor(shell, env = () => process.env) {
+        this.shell = shell;
+        this.env = env;
+    }
+    current() { return this.latest; }
+    start() {
+        if (process.platform === 'win32' || this.timer)
+            return;
+        const refresh = async () => {
+            const found = await probeToolchain(this.shell(), this.env()).catch(() => null);
+            if (found)
+                this.latest = found;
+        };
+        void refresh();
+        this.timer = setInterval(() => { void refresh(); }, TOOLCHAIN_REFRESH_MS);
+        this.timer.unref();
+    }
+    stop() { if (this.timer)
+        clearInterval(this.timer); this.timer = undefined; }
+}

package/dist/workstation/tools/browser.js

@@ -17,13 +17,31 @@ async function bounded(promise, timeout = TIMEOUT) {
         clearTimeout(timer);
     }
 }
-/** All ancestors are checked: mkdir recursive must never follow a planted profile symlink. */
+/**
+ * All ancestors are checked: mkdir recursive must never follow a planted profile symlink. The one
+ * symlinks allowed across are root-owned system symlinks (`/var -> /private/var` on macOS): stock
+ * macOS tmp dirs sit behind one, and refusing it would reject every per-user tmpdir. A root-owned
+ * symlink whose target is a root-owned, non-group-writable directory is not plantable by the user
+ * this runs as; anything else — every user-owned symlink — still fails the check below.
+ */
 async function ownedDirectory(dir, privateMode = false) {
     const absolute = path.resolve(dir);
     const parts = absolute.split(path.sep).filter(Boolean);
     let current = path.parse(absolute).root;
     const uid = process.getuid?.();
     let protectedByOwner = false;
+    const systemSymlink = async (stat) => {
+        if (stat.uid !== 0 || uid === 0)
+            return false;
+        try {
+            const target = await fs.realpath(current);
+            const targetStat = await fs.lstat(target);
+            return targetStat.isDirectory() && targetStat.uid === 0 && (targetStat.mode & 0o022) === 0;
+        }
+        catch {
+            return false;
+        }
+    };
     for (const part of parts) {
         current = path.join(current, part);
         await fs.mkdir(current, { mode: 0o700 }).catch((e) => {
@@ -31,8 +49,14 @@ async function ownedDirectory(dir, privateMode = false) {
                 throw e;
         });
         const stat = await fs.lstat(current);
+        if (stat.isSymbolicLink()) {
+            if (!(await systemSymlink(stat)))
+                throw Error("Unsafe browser directory");
+            // Root-owned system symlink: cross it; the link itself carries no mode or ownership
+            // expectation (Linux reports links 0777), its target was just verified.
+            continue;
+        }
         if (!stat.isDirectory() ||
-            stat.isSymbolicLink() ||
             (!protectedByOwner &&
                 (stat.mode & 0o022) !== 0 &&
                 !(stat.mode & 0o1000)) ||
@@ -44,11 +68,11 @@ async function ownedDirectory(dir, privateMode = false) {
         if (uid !== undefined && stat.uid === uid && (stat.mode & 0o077) === 0)
             protectedByOwner = true;
     }
-    const stat = await fs.lstat(absolute);
+    const stat = await fs.lstat(current);
     if (process.getuid && stat.uid !== process.getuid())
         throw Error("Browser directory is not owned by this user");
     if (privateMode)
-        await fs.chmod(absolute, 0o700);
+        await fs.chmod(current, 0o700);
 }
 function allowedUrl(params) {
     const url = string(params, "url", 8192, "about:blank");

package/dist/workstation/tools/client.js

@@ -8,16 +8,13 @@ import { spawn } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
 import { object, TOOL_REQUEST_BYTES, TOOL_RESULT_BYTES, validateRequest } from './validation.js';
 /** Unix socket paths must remain below macOS/Linux's ~104-byte sockaddr_un limit. */
-export function keeperPaths(options, temporaryDirectory = os.tmpdir(), platform = process.platform, kind = 'terminal') {
-    const identity = createHash('sha256').update(JSON.stringify([path.resolve(options.configDir), options.workstationId, options.server, ...(kind === 'browser' ? ['browser'] : [])])).digest('hex').slice(0, 32);
-    const namespace = `axom-${kind === 'browser' ? 'browser' : 'tools'}-${process.getuid?.() ?? 'user'}`;
-    // macOS /var/folders/.../T often exhausts sockaddr_un before adding a private namespace. Honor
-    // TMPDIR where it fits on Linux; the short system temporary root is checked for private ownership.
+export function keeperPaths(options, temporaryDirectory = os.tmpdir(), platform = process.platform, kind = 'browser') {
+    const identity = createHash('sha256').update(JSON.stringify([path.resolve(options.configDir), options.workstationId, options.server, 'browser'])).digest('hex').slice(0, 32);
+    const namespace = `axom-browser-${process.getuid?.() ?? 'user'}`;
     let dir = path.join(platform === 'darwin' ? '/tmp' : temporaryDirectory, namespace, identity);
     if (Buffer.byteLength(path.join(dir, 'keeper.sock')) > 100)
         dir = path.join('/tmp', namespace, identity);
-    // Browser ports are disjoint from terminal startup and the normal Linux ephemeral range.
-    return { dir, socket: path.join(dir, 'keeper.sock'), lock: path.join(dir, 'startup.lock'), pidFile: path.join(dir, 'keeper.pid.json'), lockPort: kind === 'browser' ? 10000 + Number.parseInt(identity.slice(0, 8), 16) % 8000 : 20000 + Number.parseInt(identity.slice(0, 8), 16) % 40000, unit: `axom-${kind === 'browser' ? 'browser' : 'tools'}-keeper-${identity}` };
+    return { dir, socket: path.join(dir, 'keeper.sock'), lock: path.join(dir, 'startup.lock'), pidFile: path.join(dir, 'keeper.pid.json'), lockPort: 10000 + Number.parseInt(identity.slice(0, 8), 16) % 8000, unit: `axom-browser-keeper-${identity}` };
 }
 export async function privateDirectory(dir) {
     await fs.mkdir(dir, { recursive: true, mode: 0o700 });
@@ -84,22 +81,16 @@ function pidAlive(pid) {
         return error.code === 'EPERM';
     }
 }
-/**
- * A tools keeper client. The daemon only ever makes the browser kind (`browser`). The kind is required — no default — so nothing can
- * start the retired terminal-kind tools keeper by accident (spec §9; terminals run in keeper-terminal, files in the daemon's files
- * host); an explicit `terminal` client exists only for the tests that pin how the retired keeper's startup and tools.info behave.
- * (`keeperPaths` keeps its terminal default: `keepers/legacy.ts` finds a legacy tools keeper an older CLI left running by it.)
- */
+/** Browser supervisor client. Native terminals use TerminalKeeperClient exclusively. */
 export class ToolsClient {
     options;
     kind;
     paths;
     starting;
-    browser;
     constructor(options, kind) {
         this.options = options;
         this.kind = kind;
-        if (kind !== 'terminal' && kind !== 'browser')
+        if (kind !== 'browser')
             throw new Error('ToolsClient needs an explicit kind (browser)');
         this.paths = keeperPaths(options, undefined, undefined, kind);
     }
@@ -121,26 +112,16 @@ export class ToolsClient {
             // Desktop sharing is optional. Checking terminal/files must not start a
             // separate browser or require its dependencies when no VNC was configured.
             const metadata = { browser: false, browserMode: 'shared', browserBinding: browserCapability(undefined) };
-            return this.kind === 'browser' ? metadata : { ...await this.localRequest(method, params), ...metadata };
+            return metadata;
         }
         if (binding && (method.startsWith('browser.') || method === 'tools.info')) {
             const metadata = { browser: true, browserMode: 'shared', browserBinding: browserCapability(binding) };
             if (method === 'browser.list')
                 return { ...metadata, sessions: [] };
             if (method === 'tools.info')
-                return this.kind === 'browser' ? metadata : { ...await this.localRequest(method, params), ...metadata };
+                return metadata;
             throw new Error('Shared browser uses the live desktop viewer; legacy browser session operations are unavailable');
         }
-        if (this.kind === 'terminal' && (method.startsWith('browser.') || method === 'tools.info')) {
-            this.browser ??= new ToolsClient(this.options, 'browser');
-            if (method.startsWith('browser.'))
-                return this.browser.request(method, params);
-            const [terminal, browser] = await Promise.all([this.localRequest(method, params), this.browser.request(method, params).catch(error => ({ browser: false, browserError: error.message }))]);
-            const result = { ...terminal, ...browser, browserMode: 'legacy', browserBinding: browserCapability(undefined) };
-            if (result.browser)
-                delete result.browserError;
-            return result;
-        }
         return this.localRequest(method, params);
     }
     async localRequest(method, params) {

package/dist/workstation/tools/info.js

@@ -1,19 +1,10 @@
 import { promises as fs } from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
-/*
- * `tools.info`, aggregated by the daemon. Consumers (analysis C §3.6): Workbench app.mjs (version), CoworkService
- * (files / mediaPreviewVersion / fileFindVersion / home / userName), files.mjs (roots / downloads / terminal),
- * terminal.mjs (home, terminal / terminalError), browser.mjs (browser* fields). Every field keeps the value and meaning
- * the legacy tools keeper gave it (tools/core.ts at the merge-base, since deleted, + tools/client.ts), and answering it never
- * starts any keeper:
- *   - file fields come from the files host's last `ready` (or are computed here before the first one); `files: true`
- *     is reported even while the host restarts, so a probe never mistakes the machine for an old CLI;
- *   - terminal fields come from keeper-terminal's hello capabilities when that keeper is already running (connecting to it,
- *     never starting it: keepers/terminal/client.ts `terminalStatus`), otherwise from a cached node-pty load check
- *     (update/ptyPreflight.ts);
- *   - browser fields come from the browser-kind ToolsClient, whose `tools.info` only returns metadata.
- */
+import { TERMINAL_GRID_SCHEMA, TERMINAL_GRID_CAPABILITY } from '../keepers/terminal/gridProtocol.js';
+/* tools.info is read-only discovery. Schema/capability describe the native contract; terminal availability
+ * comes from a current running keeper hello. The daemon's absent-keeper source is false, never a load probe
+ * promising that a future keeper will start. Files/browser discovery retain their independent metadata. */
 /** The legacy keeper always sent this (tools/core.ts at the merge-base); the browser metadata never removed it. */
 export const BROWSER_DISABLED_ERROR = 'Browser tools are not enabled in this release';
 export async function aggregateToolsInfo(sources) {
@@ -21,6 +12,8 @@ export async function aggregateToolsInfo(sources) {
     return {
         version: 1,
         terminal: terminal.terminal,
+        terminalSchema: TERMINAL_GRID_SCHEMA,
+        terminalCapability: TERMINAL_GRID_CAPABILITY,
         browser: false,
         ...files,
         ...(terminal.terminalError ? { terminalError: terminal.terminalError } : {}),