@platless/axom-cli 0.3.13 → 0.6.36

package/dist/workstation/register.js

@@ -1,46 +1,36 @@
-import { UsageError } from '../config.js';
-import { clientDir, loadClientConfig, saveClientConfig, writeKeys } from './config.js';
+import { randomUUID } from 'node:crypto';
+import { clientDir } from './config.js';
 import { osInfo } from './osinfo.js';
-export async function registerWorkstation(server, clientName, token, ws) {
-    const dir = clientDir();
-    const existing = await loadClientConfig(dir).catch(() => undefined);
-    const body = {
-        name: clientName,
-        ...(existing?.server === server ? { workstationId: existing.workstationId } : {}),
-        os: osInfo(),
-        defaultWorkspace: { name: ws.name, cwd: ws.cwd, shell: ws.shell },
-    };
+import { workstationEndpoint } from './control/serverIdentity.js';
+import { LocalControlError } from './control/protocol.js';
+import { z } from 'zod';
+export const registerResponseSchema = z.object({ workstationId: z.string().min(1), ownerUserId: z.string().min(1).optional(), clientKey: z.string(), serverPub: z.string() });
+/** No persistence; callers own the operation lock and identity transaction. */
+export async function requestWorkstationRegistration(server, clientName, token, ws, workstationId, shell = ws?.shell ?? '/bin/sh') {
     let res;
     try {
-        res = await fetch(new URL('/workstation/register', server), {
-            method: 'POST',
+        res = await fetch(workstationEndpoint(server, '/workstation/register'), { method: 'POST', redirect: 'error', signal: AbortSignal.timeout(30_000),
             headers: { 'content-type': 'application/json', authorization: `Bearer ${token}` },
-            body: JSON.stringify(body),
+            body: JSON.stringify({ name: clientName, ...(workstationId ? { workstationId } : {}), os: osInfo(), shell, ...(ws ? { defaultWorkspace: ws } : {}) }),
         });
     }
-    catch (err) {
-        throw new Error(`Failed to reach ${server}/workstation/register: ${err instanceof Error ? err.message : err}`);
+    catch {
+        throw new LocalControlError('OUTCOME_UNKNOWN', 'Registration was sent but its outcome could not be confirmed. Check your workstation list before trying again.');
+    }
+    if (res.status === 409)
+        throw new LocalControlError('BINDING_CONFLICT', 'A workstation with this name is already registered. Check Settings → Workstations.');
+    if (res.status === 401 || res.status === 403)
+        throw new LocalControlError('AUTHORIZATION_REQUIRED', 'Workstation permission is required. Run `axom auth` and select workstation, then try again.');
+    if (!res.ok)
+        throw new LocalControlError('OUTCOME_UNKNOWN', 'Registration could not be confirmed. Check your workstation list.');
+    try {
+        return registerResponseSchema.parse(await res.json());
     }
-    if (!res.ok) {
-        // A workstation with this name is already registered for this account — most commonly because
-        // this same machine registered before an axom-cli upgrade and no longer has a local config at
-        // the new config-directory path (see the client's move from ~/.axom-workstation to
-        // ~/.axom/workstation). Rebinding the existing row silently would hand this machine's identity
-        // to whichever caller re-registers next, so the server refuses instead of upserting.
-        if (res.status === 409) {
-            throw new UsageError(`A workstation named '${clientName}' is already registered for this account. This is expected `
-                + `when the same machine re-registers after an axom-cli upgrade. Delete it under Settings → `
-                + 'Workstations, then run `axom workstation start` again.');
-        }
-        if (res.status === 403) {
-            throw new UsageError('This credential is not authorized to register a workstation. '
-                + 'Run `axom auth` and select workstation, then try again.');
-        }
-        throw new Error(`Registration failed: ${res.status} ${await res.text()}`);
+    catch {
+        throw new LocalControlError('OUTCOME_UNKNOWN', 'Registration response was incomplete. Check your workstation list.');
     }
-    const data = (await res.json());
-    if (!data.workstationId)
-        throw new Error('Registration response missing workstationId');
-    await saveClientConfig(dir, { server, workstationId: data.workstationId, workspaces: [{ name: ws.name, cwd: ws.cwd }] });
-    await writeKeys(dir, data.clientKey, data.serverPub);
+}
+export async function registerWorkstation(server, clientName, token, ws) {
+    const { enrollLegacyWorkstation } = await import('./control/enrollment.js');
+    await enrollLegacyWorkstation({ server, name: clientName, accessToken: token, workspace: ws, operationId: randomUUID() }, clientDir());
 }

package/dist/workstation/service/installer.js

@@ -58,6 +58,22 @@ async function assertWritable(directory) {
 }
 const defaultDeps = {
     run: runProcess,
+    readLaunchAgent: async (file) => {
+        const handle = await fs.open(file, fs.constants.O_RDONLY | fs.constants.O_NOFOLLOW);
+        try {
+            const stat = await handle.stat();
+            if (!stat.isFile() || stat.size > 65536)
+                throw new Error('Invalid LaunchAgent');
+        }
+        finally {
+            await handle.close();
+        }
+        const result = await runProcess('/usr/bin/plutil', ['-convert', 'json', '-o', '-', file]);
+        const value = JSON.parse(result.stdout);
+        if (!value || typeof value !== 'object' || Array.isArray(value))
+            throw new Error('Invalid LaunchAgent');
+        return value;
+    },
     writeTemp,
     assertWritable,
     ensureDirectory: async (directory) => { await fs.mkdir(directory, { recursive: true }); },
@@ -219,24 +235,38 @@ export function createServiceManager(context, overrides = {}) {
         // durable LaunchAgent plist. This keeps explicit stop meaningful across both service managers.
         if (action === 'stop')
             return deps.run('launchctl', ['bootout', launchdDomain]);
-        if (action === 'restart') {
-            try {
-                await deps.run('launchctl', ['bootout', launchdDomain]);
-            }
-            catch (error) {
-                // `restart` after an explicit `stop` is a valid request: absence means there is nothing
-                // left to unload, and launchdStart will bootstrap the durable plist.
-                if (!launchdAbsent(error))
-                    throw error;
+        return launchdStart();
+    };
+    const enabled = async (plistDisabled = false) => {
+        if (context.platform === 'darwin') {
+            const result = await deps.run('launchctl', ['print-disabled', `gui/${context.userId}`]);
+            if (!result.stdout.includes('{') || !result.stdout.includes('}'))
+                throw new Error('Cannot determine launchd enablement');
+            const line = result.stdout.split('\n').find(line => line.includes(`"${SERVICE_LABEL}"`));
+            if (line) {
+                const override = /=>\s*(true|false|enabled|disabled)\b/.exec(line);
+                if (!override)
+                    throw new Error('Cannot determine launchd enablement');
+                return override[1] === 'true' || override[1] === 'disabled' ? false : true;
             }
-            return launchdStart();
+            return !plistDisabled;
+        }
+        try {
+            return (await deps.run('systemctl', ['--user', 'is-enabled', `${SERVICE_LABEL}.service`])).stdout.trim() === 'enabled';
+        }
+        catch (error) {
+            if (/disabled|not-found/.test(String(error)))
+                return false;
+            throw error;
         }
-        return launchdStart();
     };
     // Extracted so `start()` can reuse it: reinstalling is the same work whether triggered
     // explicitly (`axom workstation install`) or as `start()`'s self-heal for a missing definition
     // file. Both platform branches leave the service running, so callers need no separate start.
     const performInstall = async (_options = {}) => {
+        const present = await deps.pathExists(target);
+        const plistDisabled = context.platform === 'darwin' && present && (await deps.readLaunchAgent(target)).Disabled === true;
+        const preserveDisabled = (context.platform === 'darwin' || present) && !await enabled(plistDisabled);
         await deps.assertWritable(context.npmPrefix);
         await deps.ensureDirectory(path.dirname(target));
         const temp = await deps.writeTemp(contents);
@@ -246,7 +276,8 @@ export function createServiceManager(context, overrides = {}) {
             await deps.run('mv', [targetTemp, target]);
             if (context.platform === 'linux') {
                 await deps.run('systemctl', ['--user', 'daemon-reload']);
-                await deps.run('systemctl', ['--user', 'enable', '--now', `${SERVICE_LABEL}.service`]);
+                if (!preserveDisabled)
+                    await deps.run('systemctl', ['--user', 'enable', '--now', `${SERVICE_LABEL}.service`]);
             }
             else {
                 // Reload an existing service before bootstrapping the replacement into the GUI domain.
@@ -255,7 +286,8 @@ export function createServiceManager(context, overrides = {}) {
                 // bounded probe/bootstrap path so Bootstrap failed: 5 is confirmed then kickstarted, and
                 // so a launchd that never releases the job is reported instead of leaving the machine
                 // with the bootout applied and nothing bootstrapped in its place.
-                await launchdStart();
+                if (!preserveDisabled)
+                    await launchdStart();
             }
         }
         finally {
@@ -303,6 +335,11 @@ export function createServiceManager(context, overrides = {}) {
          */
         async start() {
             await withGuiSessionHint(async () => {
+                // An explicit Start is consent to re-enable; install/update alone preserves OFF.
+                if (context.platform === 'darwin')
+                    await deps.run('launchctl', ['enable', launchdDomain]);
+                else
+                    await deps.run('systemctl', ['--user', 'enable', `${SERVICE_LABEL}.service`]);
                 if (!(await deps.pathExists(target)))
                     await performInstall({});
                 await lifecycle('start');
@@ -310,6 +347,60 @@ export function createServiceManager(context, overrides = {}) {
         },
         async stop() { await withGuiSessionHint(() => lifecycle('stop')); },
         async restart() { await withGuiSessionHint(() => lifecycle('restart')); },
+        async setEnabled(value) {
+            await withGuiSessionHint(async () => {
+                if (context.platform === 'darwin') {
+                    await deps.run('launchctl', [value ? 'enable' : 'disable', launchdDomain]);
+                    if (value) {
+                        if (!await deps.pathExists(target))
+                            await performInstall({});
+                        await launchdStart();
+                    }
+                    else {
+                        try {
+                            await lifecycle('stop');
+                        }
+                        catch (error) {
+                            if (!launchdAbsent(error))
+                                throw error;
+                        }
+                    }
+                }
+                else
+                    await deps.run('systemctl', ['--user', value ? 'enable' : 'disable', '--now', `${SERVICE_LABEL}.service`]);
+            });
+        },
+        async enablement() {
+            const installed = await deps.pathExists(target);
+            if (!installed)
+                return { installed: false, enabled: false, loaded: false, running: false };
+            let value;
+            try {
+                let disabled = false;
+                if (context.platform === 'darwin') {
+                    const plist = await deps.readLaunchAgent(target);
+                    const args = plist.ProgramArguments;
+                    const environment = plist.EnvironmentVariables;
+                    if (plist.Label !== SERVICE_LABEL || !Array.isArray(args) || args.length !== 3 || args[0] !== context.nodePath || args[1] !== context.cliPath || args[2] !== '__daemon' || environment?.AXOM_WORKSTATION_CONFIG_DIR !== context.configDir) {
+                        return { installed, enabled: null, loaded: false, running: false, reason: 'service_identity_mismatch' };
+                    }
+                    disabled = plist.Disabled === true;
+                }
+                value = await enabled(disabled);
+            }
+            catch {
+                return { installed, enabled: null, loaded: false, running: false, reason: 'service_state_unknown' };
+            }
+            try {
+                const result = await lifecycle('status');
+                return { installed, enabled: value, loaded: true, running: context.platform === 'darwin' ? launchdIsRunning(result.stdout) : true };
+            }
+            catch (error) {
+                if (launchdAbsent(error) || /inactive|not loaded|not-found/.test(String(error)))
+                    return { installed, enabled: value, loaded: false, running: false };
+                return { installed, enabled: value, loaded: false, running: false, reason: 'runtime_state_unknown' };
+            }
+        },
         async status() {
             try {
                 const result = await lifecycle('status');

package/dist/workstation/service/launchd.js

@@ -31,6 +31,7 @@ ${keyValue('AXOM_WORKSTATION_CONFIG_DIR', context.configDir)}
 ${keyValue('AXOM_WORKSTATION_NPM_PATH', context.npmPath)}
 ${keyValue('AXOM_WORKSTATION_NPM_PREFIX', context.npmPrefix)}
 ${keyValue('PATH', context.pathEnv)}
+${context.npmConfigPrefix ? keyValue('NPM_CONFIG_PREFIX', context.npmConfigPrefix) : ''}
 \t</dict>
 \t<key>StandardOutPath</key>
 \t<string>${xml(`${context.configDir}/daemon.log`)}</string>

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()];
+}