@platless/axom-cli 0.1.0

package/dist/commands/workstation.js

@@ -0,0 +1,171 @@
+import { hostname } from 'node:os';
+import { basename } from 'node:path';
+import { loadConfig, resolveServer, UsageError } from '../config.js';
+import { accessTokenFor } from '../credentials.js';
+import { ensureFreshToken } from '../mcp.js';
+import { runCommand } from '../output.js';
+import { clientDir, loadClientConfig } from '../workstation/config.js';
+import { resolveWorkstationName, sanitizeName } from '../workstation/names.js';
+/**
+ * Registers this workstation with the server if it has no credential yet, then leaves it alone.
+ * Returns whether it just registered (`false` when an existing credential meant there was nothing
+ * to do), so `start` can gate `install()` on that — see its action below for why that gate matters.
+ *
+ * Shared by `start` (which then hands off to the OS service) and the bare `axom workstation`
+ * command (which runs the daemon directly): both need the exact same credential chain, so it lives
+ * here once rather than twice.
+ *
+ * An existing workstation credential boots directly — the common case, and the only sane one for a
+ * container that gets recreated on every restart: re-registering each boot would rotate keys for no
+ * reason. Otherwise a usable access token registers this machine — `AXOM_ACCESS_TOKEN` (set by a
+ * container with no human and no browser) or a stored user token (from `axom auth`), refreshing it
+ * first if it's stale. With neither available, an interactive terminal falls back to the device
+ * flow; a headless one gets a hard stop naming the fix.
+ */
+async function ensureRegistered(deps, serverFlag, nameFlag) {
+    const registered = await loadClientConfig(clientDir()).then(() => true, () => false);
+    if (registered)
+        return false;
+    const config = await loadConfig();
+    const server = resolveServer(config, serverFlag);
+    let token = await accessTokenFor(server);
+    if (!token) {
+        if (!deps.isInteractive()) {
+            throw new UsageError('No credential for this workstation. Set AXOM_ACCESS_TOKEN (create one under Settings → Security → ' +
+                'Access Tokens), or run `axom auth` on a machine with a browser.');
+        }
+        await deps.authenticate(server);
+        token = await ensureFreshToken(server);
+    }
+    const cwd = process.cwd();
+    await deps.registerWorkstation(server, resolveWorkstationName(nameFlag, process.env, hostname()), token, {
+        name: sanitizeName(basename(cwd), 'default'),
+        cwd,
+        shell: process.env.SHELL ?? '/bin/bash',
+    });
+    return true;
+}
+/**
+ * Removes `AXOM_ACCESS_TOKEN` from *this process's* copy of the environment, right before the bare
+ * `axom workstation` command becomes a long-lived daemon.
+ *
+ * The daemon spawns agents and shell commands with `{ ...process.env, ... }` (exec.ts, acpClient.ts),
+ * so anything still in here reaches every model-authored command and every dependency postinstall
+ * that runs in `/workspace` — a container is precisely where this product runs untrusted code. What
+ * would leak is not the workstation's own key pair (scoped to one workstation, on disk) but a
+ * credential that authenticates *as the user*: it can register further workstations under their
+ * account and, with the `mcp` scope, call every MCP tool as them, until somebody notices and revokes
+ * it. Fixed once here rather than filtered at each of the two spawn sites, so the next spawn site
+ * inherits the fix instead of having to remember it.
+ *
+ * Nothing after this point needs the value. The daemon authenticates with the file credential
+ * written at registration (`clientKey`/`serverPub`), and the `container` update lifecycle downloads
+ * its release over that same authenticated management channel.
+ *
+ * Unconditional, not gated on "we just registered": a container that still has its `/data/ws` volume
+ * boots straight past `ensureRegistered`, and that is exactly the long-lived container this protects.
+ *
+ * The token stays in the *container's* environment, so a restarted container still registers — only
+ * this process's copy is dropped. Every reader of it lives before this line: `accessTokenFor`
+ * (credentials.ts) reads `process.env.AXOM_ACCESS_TOKEN` on its first line, and its only caller here
+ * is `ensureRegistered` above; `insufficientScopeError`/`envAccessTokenRejectedError` (mcp.ts) read
+ * it too, but only from the one-shot `axom execute`/`axom struct` CLI processes, which are separate
+ * processes with their own untouched copy.
+ *
+ * `workstation start` deliberately does not call this: it registers and hands off to launchd/systemd
+ * rather than becoming the daemon, so dropping the variable would affect only a CLI process that is
+ * about to exit.
+ */
+function dropAccessTokenFromEnvironment() {
+    delete process.env.AXOM_ACCESS_TOKEN;
+}
+/**
+ * Registers `axom workstation start|stop|restart|status|install|uninstall`, the bare
+ * `axom workstation` (Docker ENTRYPOINT / debugging foreground run), and the hidden top-level
+ * `axom __daemon`.
+ *
+ * `__daemon` is registered on `program` itself, not on the `workstation` subcommand group: the
+ * generated launchd/systemd service definitions invoke it as `<cliPath> __daemon`, a bare
+ * top-level argument (see service/launchd.ts and service/systemd.ts).
+ */
+export function registerWorkstationCommands(program, deps) {
+    const workstation = program.command('workstation').description('Manage the local Axomwork workstation daemon');
+    // Same idiom as `registerUpdateCommand`: the global `--server` is read at action time, not at
+    // registration time, so `axom --server <url> workstation start` works. `axom auth` only writes
+    // `defaultServer` when it is unset, so a user who authenticated against localhost first and
+    // production second would otherwise have no way to keep `start` off localhost.
+    const serverOption = () => program.opts().server;
+    // `workstation` (this group) and its `start` subcommand both declare `--server`/`--name` — the
+    // group needs its own copy so the *bare* command accepts them, and `start` keeps its copy for its
+    // own `--help`. But for `axom workstation start --server/--name <value>`, only one of the two
+    // declarations ever actually captures the flag, and it's not always the same one: `program`
+    // parses its own options over the *entire* remaining argv before `workstation` gets a look, so
+    // `--server` — also declared on `program`, globally — is always captured there, leaving both
+    // `options.server` and `workstationOption().server` dead; `--name` has no `program`-level
+    // declaration, so it falls through to `workstation`, which *does* capture it, leaving `start`'s
+    // own `options.name` the dead one instead. `start`'s action below reads the whole fallback chain
+    // so it doesn't matter which link is live for a given flag.
+    const workstationOption = () => workstation.opts();
+    workstation
+        .command('start')
+        .option('--server <url>', 'Axomwork server URL to register this workstation against')
+        .option('--name <name>', 'Workstation name (default: AXOM_WORKSTATION_NAME, then the hostname)')
+        .description('Start the workstation user service')
+        .action((options) => runCommand(async () => {
+        // `install()` runs only when this call just registered the workstation, not on every
+        // `start` — it's not the free idempotent no-op it looks like. On macOS it's bootout, write
+        // plist, bootstrap, and the `deps.start()` right after it is `kickstart -k`: on an
+        // already-registered machine that's two restart windows where there used to be one, plus a
+        // bootout window with a documented stranding mode (`launchdStuck`: the service is not
+        // registered with launchd right now, so nothing will start it). It would also re-pin the
+        // service's `node` execPath to whatever ran this `start` — which repairs a machine stranded
+        // by a removed nvm version only if that's a *good* node; run from an ad-hoc one and it
+        // manufactures the exact stranding it's meant to cure. That repair belongs to the explicit
+        // verb that already exists for it, `axom workstation install`, not as a side effect here.
+        const justRegistered = await ensureRegistered(deps, options.server ?? workstationOption().server ?? serverOption(), options.name ?? workstationOption().name);
+        if (justRegistered)
+            await deps.install();
+        await deps.start();
+    }));
+    workstation
+        .command('stop')
+        .description('Stop the workstation user service')
+        .action(() => runCommand(async () => { await deps.stop(); }));
+    workstation
+        .command('restart')
+        .description('Restart the workstation user service')
+        .action(() => runCommand(async () => { await deps.restart(); }));
+    workstation
+        .command('status')
+        .description('Report whether the workstation daemon is running')
+        .action(() => runCommand(async () => { deps.log(await deps.status()); }));
+    workstation
+        .command('install')
+        .description('Install and enable the operating-system service')
+        .action(() => runCommand(async () => { await deps.install(); }));
+    workstation
+        .command('uninstall')
+        .description('Disable and remove the operating-system service')
+        .action(() => runCommand(async () => { await deps.uninstall(); }));
+    workstation
+        .option('--server <url>', 'Axomwork server URL to register against (default: AXOM_SERVER, then the stored default)')
+        .option('--name <name>', 'Workstation name (default: AXOM_WORKSTATION_NAME, then the hostname)')
+        .description('Run the workstation daemon in the foreground (Docker ENTRYPOINT / debugging); subcommands manage the OS service')
+        .action((options) => runCommand(async () => {
+        await ensureRegistered(deps, options.server ?? serverOption(), options.name);
+        dropAccessTokenFromEnvironment();
+        await deps.runDaemon({ supervision: deps.detectSupervision() });
+    }));
+    program.command('__daemon', { hidden: true }).action(() => runCommand(async () => {
+        // The literal exec target launchd/systemd start: the one call site allowed to opt into
+        // OS-service treatment. See RunDaemonOptions in daemon.ts for why this must be an explicit
+        // flag rather than "no `supervision` was passed".
+        //
+        // Same reasoning as the bare command's call: this process is about to become the daemon that
+        // spawns agents and shell commands with its own environment. A service definition is not
+        // supposed to carry AXOM_ACCESS_TOKEN at all, which makes this usually a no-op — and exactly
+        // why it belongs here rather than being left to whoever writes the next plist.
+        dropAccessTokenFromEnvironment();
+        await deps.runDaemon({ supervisedByServiceManager: true });
+    }));
+}

package/dist/config.js

@@ -0,0 +1,131 @@
+import { promises as fs } from 'node:fs';
+import { randomUUID } from 'node:crypto';
+import { homedir } from 'node:os';
+import path from 'node:path';
+export class UsageError extends Error {
+}
+export class AuthError extends Error {
+}
+export function configPath() {
+    return path.join(configDir(), 'config.json');
+}
+function configDir() {
+    return process.env.AXOM_CONFIG_DIR ?? path.join(homedir(), '.axom');
+}
+/**
+ * This install's stable id, kept beside the config as `device-id`.
+ *
+ * The server keys one session row per (user, client, device), so this is what makes one machine one
+ * row on the Security page however often the CLI refreshes its token. It lives in the config
+ * directory rather than the keyring on purpose: it is not a secret, and AXOM_CONFIG_DIR already
+ * defines what "this install" means for everything else the CLI remembers.
+ *
+ * Never throws: an unwritable config directory yields a per-run id, which is worse for the session
+ * list but must not stop the CLI from authenticating.
+ */
+export async function loadDeviceId() {
+    const file = path.join(configDir(), 'device-id');
+    try {
+        const existing = (await fs.readFile(file, 'utf8')).trim();
+        if (existing)
+            return existing;
+    }
+    catch (error) {
+        if (!(isNodeError(error) && error.code === 'ENOENT'))
+            return randomUUID();
+    }
+    const minted = randomUUID();
+    try {
+        await fs.mkdir(path.dirname(file), { recursive: true });
+        await fs.writeFile(file, `${minted}\n`, { mode: 0o600 });
+    }
+    catch {
+        // Unwritable config dir: the id cannot be remembered, but the caller still gets a usable one.
+    }
+    return minted;
+}
+export async function loadConfig() {
+    const file = configPath();
+    try {
+        const raw = await fs.readFile(file, 'utf8');
+        return parseConfig(JSON.parse(raw), file);
+    }
+    catch (error) {
+        if (isNodeError(error) && error.code === 'ENOENT')
+            return { servers: {} };
+        if (error instanceof SyntaxError) {
+            throw new Error(`Failed to parse Axomwork config at ${file}: ${error.message}`);
+        }
+        throw error;
+    }
+}
+const obsoleteCredentialKeys = new Set(['clientId', 'accessToken', 'refreshToken', 'expiresAt']);
+function parseConfig(value, file) {
+    if (!isRecord(value))
+        throw invalidConfig(file, 'the root value must be an object');
+    const rootKeys = Object.keys(value);
+    const unknownRootKey = rootKeys.find((key) => key !== 'defaultServer' && key !== 'servers');
+    if (unknownRootKey)
+        throw invalidConfig(file, `unknown root key '${unknownRootKey}'`);
+    if (value.defaultServer !== undefined && typeof value.defaultServer !== 'string') {
+        throw invalidConfig(file, 'defaultServer must be a string');
+    }
+    if (!isRecord(value.servers))
+        throw invalidConfig(file, 'servers must be an object');
+    const servers = {};
+    for (const [server, entry] of Object.entries(value.servers)) {
+        if (!isRecord(entry))
+            throw invalidConfig(file, `server entry '${server}' must be an object`);
+        const obsoleteKey = Object.keys(entry).find((key) => obsoleteCredentialKeys.has(key));
+        if (obsoleteKey) {
+            throw new Error(`Unsupported credential format in Axomwork config at ${file}: server '${server}' contains obsolete key '${obsoleteKey}'. ` +
+                'Remove that server entry and run axom auth again.');
+        }
+        const unknownKey = Object.keys(entry).find((key) => key !== 'authenticated');
+        if (unknownKey)
+            throw invalidConfig(file, `server entry '${server}' has unknown key '${unknownKey}'`);
+        if (entry.authenticated !== undefined && typeof entry.authenticated !== 'boolean') {
+            throw invalidConfig(file, `server entry '${server}'.authenticated must be a boolean`);
+        }
+        servers[server] = entry.authenticated === true ? { authenticated: true } : {};
+    }
+    return { defaultServer: value.defaultServer, servers };
+}
+function invalidConfig(file, reason) {
+    return new Error(`Invalid Axomwork config at ${file}: ${reason}.`);
+}
+export async function saveConfig(config) {
+    const file = configPath();
+    const safeConfig = {
+        defaultServer: config.defaultServer,
+        servers: Object.fromEntries(Object.entries(config.servers).map(([server, value]) => [
+            server,
+            value.authenticated === true ? { authenticated: true } : {},
+        ])),
+    };
+    await fs.mkdir(path.dirname(file), { recursive: true });
+    await fs.writeFile(file, `${JSON.stringify(safeConfig, null, 2)}\n`, { mode: 0o600 });
+    await fs.chmod(file, 0o600);
+}
+export function resolveServer(config, flag, env = process.env) {
+    // A blank AXOM_SERVER (unset in a container's env file, or literally "") counts as unset, not
+    // as a value that should win over the stored default.
+    const fromEnv = env.AXOM_SERVER?.trim() || undefined;
+    const selected = flag ?? fromEnv ?? config.defaultServer;
+    if (!selected) {
+        throw new UsageError('No Axomwork server configured. Pass --server <url>, set AXOM_SERVER, or run axom auth --server <url>.');
+    }
+    return normalizeServerUrl(selected);
+}
+function normalizeServerUrl(value) {
+    const trimmed = value.trim();
+    if (!trimmed)
+        throw new UsageError('Server URL must not be blank.');
+    return trimmed.replace(/\/+$/, '');
+}
+function isNodeError(error) {
+    return error instanceof Error && 'code' in error;
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}

package/dist/credentialBroker.js

@@ -0,0 +1,340 @@
+import { spawn } from 'node:child_process';
+import { promises as fs } from 'node:fs';
+import net from 'node:net';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+const PROTOCOL_VERSION = 1;
+const SERVICE_LABEL = 'com.platless.axom-credentials';
+const MAX_MESSAGE_BYTES = 64 * 1024;
+// This is one deadline for the initial request, service startup, retry sleeps, and every retry. A
+// Keychain call may cold-start the Security framework or wait for macOS authorization, but the
+// complete external-initialization boundary must still remain bounded.
+const BROKER_OPERATION_TIMEOUT_MS = 30_000;
+const PEER_DISCONNECT_CODES = new Set(['EPIPE', 'ECONNRESET']);
+class BrokerOperationError extends Error {
+}
+const uid = () => process.getuid?.() ?? os.userInfo().uid;
+const socketPath = () => `/tmp/${SERVICE_LABEL}.${uid()}.sock`;
+const launchAgentPath = () => path.join(os.homedir(), 'Library', 'LaunchAgents', `${SERVICE_LABEL}.plist`);
+const stateDirectory = () => path.join(os.homedir(), 'Library', 'Caches', SERVICE_LABEL);
+const cliPath = () => path.join(path.dirname(fileURLToPath(import.meta.url)), 'cli.js');
+export async function requestCredentialBroker(request) {
+    if (process.platform !== 'darwin')
+        throw new Error('The Axomwork credential broker is available only on macOS.');
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(new Error('Axomwork credential broker operation timed out.')), BROKER_OPERATION_TIMEOUT_MS);
+    const brokerRequest = { version: PROTOCOL_VERSION, ...request };
+    try {
+        try {
+            return await sendRequest(brokerRequest, controller.signal);
+        }
+        catch (error) {
+            if (error instanceof BrokerOperationError)
+                throw error;
+            throwIfAborted(controller.signal);
+            await installAndStartBroker(controller.signal);
+            let lastError;
+            for (let attempt = 0; attempt < 20; attempt += 1) {
+                await abortableDelay(100, controller.signal);
+                try {
+                    return await sendRequest(brokerRequest, controller.signal);
+                }
+                catch (retryError) {
+                    if (retryError instanceof BrokerOperationError)
+                        throw retryError;
+                    throwIfAborted(controller.signal);
+                    lastError = retryError;
+                }
+            }
+            throw new Error(`Axomwork could not connect to its macOS credential broker: ${message(lastError)}`);
+        }
+    }
+    catch (error) {
+        if (!(error instanceof BrokerOperationError))
+            throwIfAborted(controller.signal);
+        throw error;
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+export async function runCredentialBroker() {
+    if (process.platform !== 'darwin')
+        throw new Error('The Axomwork credential broker is available only on macOS.');
+    await fs.mkdir(stateDirectory(), { recursive: true, mode: 0o700 });
+    await removeStaleSocket();
+    const credentials = await import('./credentials.js');
+    const server = net.createServer((connection) => {
+        let raw = '';
+        let handled = false;
+        connection.on('error', (error) => {
+            // The credential operation may finish after its caller has gone away. That is not a broker
+            // failure; every other socket error still terminates the service through its normal error path.
+            if (!PEER_DISCONNECT_CODES.has(error.code ?? ''))
+                server.emit('error', error);
+        });
+        connection.setEncoding('utf8');
+        connection.on('data', (chunk) => {
+            raw += chunk;
+            if (Buffer.byteLength(raw) > MAX_MESSAGE_BYTES) {
+                connection.destroy(new Error('Credential broker request is too large.'));
+                return;
+            }
+            if (!handled && raw.includes('\n')) {
+                handled = true;
+                void handleRequest(raw, connection, credentials);
+            }
+        });
+    });
+    await new Promise((resolve, reject) => {
+        const onError = (error) => {
+            server.off('error', onError);
+            reject(error);
+        };
+        server.once('error', onError);
+        server.listen(socketPath(), () => {
+            server.off('error', onError);
+            resolve();
+        });
+    });
+    await fs.chmod(socketPath(), 0o600);
+    const shutdown = () => {
+        server.close(() => { void fs.rm(socketPath(), { force: true }).finally(() => process.exit(0)); });
+    };
+    process.once('SIGINT', shutdown);
+    process.once('SIGTERM', shutdown);
+    await new Promise((resolve, reject) => {
+        const onClose = () => {
+            server.off('error', onError);
+            resolve();
+        };
+        const onError = (error) => {
+            server.off('close', onClose);
+            reject(error);
+        };
+        server.once('close', onClose);
+        server.once('error', onError);
+    });
+}
+async function handleRequest(raw, connection, credentials) {
+    let response;
+    try {
+        const request = parseRequest(raw.slice(0, raw.indexOf('\n')));
+        if (request.action === 'save') {
+            await credentials.saveNativeTokens(request.server, request.tokens);
+            response = { ok: true, version: PROTOCOL_VERSION };
+        }
+        else if (request.action === 'access') {
+            const accessToken = await credentials.accessTokenFromNativeStore(request.server, request.forceRefresh);
+            response = { ok: true, accessToken, version: PROTOCOL_VERSION };
+        }
+        else if (request.action === 'revoke') {
+            const persisted = await credentials.loadNativeTokens(request.server);
+            if (persisted?.refreshToken)
+                await credentials.revokeRefreshToken(request.server, persisted.refreshToken);
+            await credentials.clearNativeTokens(request.server);
+            response = { ok: true, version: PROTOCOL_VERSION };
+        }
+        else {
+            await credentials.clearNativeTokens(request.server);
+            response = { ok: true, version: PROTOCOL_VERSION };
+        }
+    }
+    catch (error) {
+        response = { ok: false, error: message(error), version: PROTOCOL_VERSION };
+    }
+    connection.end(`${JSON.stringify(response)}\n`);
+}
+async function sendRequest(request, signal) {
+    throwIfAborted(signal);
+    await assertSafeSocket();
+    throwIfAborted(signal);
+    return new Promise((resolve, reject) => {
+        const connection = net.createConnection(socketPath());
+        let raw = '';
+        let settled = false;
+        const finish = (action) => {
+            if (settled)
+                return;
+            settled = true;
+            signal.removeEventListener('abort', onAbort);
+            action();
+        };
+        const onAbort = () => {
+            connection.destroy();
+            finish(() => reject(abortReason(signal)));
+        };
+        connection.setEncoding('utf8');
+        connection.once('connect', () => connection.write(`${JSON.stringify(request)}\n`));
+        connection.on('data', (chunk) => {
+            raw += chunk;
+            if (Buffer.byteLength(raw) > MAX_MESSAGE_BYTES)
+                connection.destroy(new Error('Credential broker response is too large.'));
+        });
+        connection.once('error', (error) => finish(() => reject(error)));
+        connection.once('end', () => {
+            finish(() => {
+                try {
+                    const response = JSON.parse(raw);
+                    if (response.version !== PROTOCOL_VERSION)
+                        throw new Error('Credential broker protocol version mismatch.');
+                    if (!response.ok)
+                        throw new BrokerOperationError(response.error || 'Credential broker request failed.');
+                    resolve(response);
+                }
+                catch (error) {
+                    reject(error);
+                }
+            });
+        });
+        signal.addEventListener('abort', onAbort, { once: true });
+        if (signal.aborted)
+            onAbort();
+    });
+}
+async function assertSafeSocket() {
+    const stat = await fs.lstat(socketPath());
+    if (!stat.isSocket() || stat.uid !== uid() || (stat.mode & 0o077) !== 0) {
+        throw new Error('Axomwork credential broker socket has unsafe ownership or permissions.');
+    }
+}
+async function removeStaleSocket() {
+    try {
+        const stat = await fs.lstat(socketPath());
+        if (stat.uid !== uid())
+            throw new Error('Refusing to replace a credential broker socket owned by another user.');
+        await fs.rm(socketPath());
+    }
+    catch (error) {
+        if (error.code !== 'ENOENT')
+            throw error;
+    }
+}
+async function installAndStartBroker(signal) {
+    throwIfAborted(signal);
+    const agent = launchAgentPath();
+    await fs.mkdir(path.dirname(agent), { recursive: true });
+    throwIfAborted(signal);
+    await fs.mkdir(stateDirectory(), { recursive: true, mode: 0o700 });
+    throwIfAborted(signal);
+    const temporary = `${agent}.${process.pid}.tmp`;
+    await fs.writeFile(temporary, renderLaunchAgent(), { mode: 0o644 });
+    throwIfAborted(signal);
+    await fs.rename(temporary, agent);
+    throwIfAborted(signal);
+    const domain = `gui/${uid()}`;
+    const service = `${domain}/${SERVICE_LABEL}`;
+    try {
+        await runLaunchctl(['bootout', service], signal);
+    }
+    catch {
+        throwIfAborted(signal);
+    }
+    await abortableDelay(100, signal);
+    try {
+        await runLaunchctl(['bootstrap', domain, agent], signal);
+    }
+    catch (error) {
+        if (/Domain does not support specified action/i.test(message(error))) {
+            throw new Error('No macOS GUI login session is available. Log in at the console before using Keychain credentials from SSH.');
+        }
+        throw error;
+    }
+}
+async function runLaunchctl(args, signal) {
+    throwIfAborted(signal);
+    await new Promise((resolve, reject) => {
+        const child = spawn('/bin/launchctl', args, { shell: false, stdio: ['ignore', 'ignore', 'pipe'] });
+        let stderr = '';
+        let settled = false;
+        const finish = (action) => {
+            if (settled)
+                return;
+            settled = true;
+            signal.removeEventListener('abort', onAbort);
+            action();
+        };
+        const onAbort = () => {
+            try {
+                child.kill('SIGKILL');
+            }
+            catch {
+                // The deadline result is authoritative even if the already-exiting child rejects the kill.
+            }
+            finish(() => reject(abortReason(signal)));
+        };
+        child.stderr.on('data', (chunk) => { if (stderr.length < 4096)
+            stderr += chunk.toString(); });
+        child.once('error', (error) => finish(() => reject(error)));
+        child.once('close', (code) => finish(() => code === 0
+            ? resolve()
+            : reject(new Error(`launchctl ${args[0]} failed (${code}): ${stderr.trim()}`))));
+        signal.addEventListener('abort', onAbort, { once: true });
+        if (signal.aborted)
+            onAbort();
+    });
+}
+async function abortableDelay(milliseconds, signal) {
+    throwIfAborted(signal);
+    await new Promise((resolve, reject) => {
+        let settled = false;
+        const timeout = setTimeout(() => finish(resolve), milliseconds);
+        const onAbort = () => finish(() => reject(abortReason(signal)));
+        const finish = (action) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timeout);
+            signal.removeEventListener('abort', onAbort);
+            action();
+        };
+        signal.addEventListener('abort', onAbort, { once: true });
+        if (signal.aborted)
+            onAbort();
+    });
+}
+function throwIfAborted(signal) {
+    if (signal.aborted)
+        throw abortReason(signal);
+}
+function abortReason(signal) {
+    return signal.reason instanceof Error ? signal.reason : new Error('Axomwork credential broker operation timed out.');
+}
+function renderLaunchAgent() {
+    const log = path.join(stateDirectory(), 'broker.log');
+    return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0"><dict>
+<key>Label</key><string>${SERVICE_LABEL}</string>
+<key>ProgramArguments</key><array><string>${xml(process.execPath)}</string><string>${xml(cliPath())}</string><string>__credential-broker</string></array>
+<key>EnvironmentVariables</key><dict><key>HOME</key><string>${xml(os.homedir())}</string></dict>
+<key>StandardOutPath</key><string>${xml(log)}</string>
+<key>StandardErrorPath</key><string>${xml(log)}</string>
+<key>RunAtLoad</key><true/><key>KeepAlive</key><true/>
+</dict></plist>
+`;
+}
+function parseRequest(raw) {
+    const request = JSON.parse(raw);
+    if (request.version !== PROTOCOL_VERSION)
+        throw new Error('Unsupported credential broker protocol version.');
+    if (request.action !== 'save' && request.action !== 'access' && request.action !== 'clear' && request.action !== 'revoke') {
+        throw new Error('Unsupported credential broker operation.');
+    }
+    if (typeof request.server !== 'string' || !request.server)
+        throw new Error('Credential broker request has no server.');
+    if (request.action === 'save') {
+        const tokens = request.tokens;
+        if (!tokens || typeof tokens.accessToken !== 'string' || typeof tokens.refreshToken !== 'string' || typeof tokens.expiresAt !== 'string') {
+            throw new Error('Credential broker save request has invalid tokens.');
+        }
+    }
+    return request;
+}
+function xml(value) {
+    return value.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;').replace(/'/g, '&apos;');
+}
+function message(error) {
+    return error instanceof Error ? error.message : String(error);
+}