@craftspace/cli 0.1.0

package/dist/machine.d.ts

@@ -0,0 +1,21 @@
+import { type Machine } from '@craftspace/shared';
+export declare const machine: {
+    home(): string;
+    login({ token, url, install }: {
+        token: string;
+        url: string;
+        install: boolean;
+    }): Promise<Machine>;
+    status(): Promise<{
+        machine: Machine;
+        url: string;
+    } | null>;
+    beatOnce(): Promise<boolean>;
+    beatForever(): Promise<void>;
+    run({ argv, on }: {
+        argv: string[];
+        on?: string;
+    }): Promise<number>;
+    logout(): Promise<void>;
+};
+export declare function nextDelayMs(failures: number, busy?: boolean): number;

package/dist/machine.js

@@ -0,0 +1,472 @@
+import { execFile } from 'node:child_process';
+import { mkdir, readFile, readdir, rm, writeFile } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { promisify } from 'node:util';
+import { CLI_VERSION, MACHINE_BEAT_BUSY_INTERVAL_MS, MACHINE_BEAT_INTERVAL_MS, MachineBeatResponseSchema, MachineLoginResponseSchema, MachineRunSchema, MachineRunsResponseSchema, MachineSchema, MachineSessionSchema, MachinesResponseSchema, } from '@craftspace/shared';
+import { z } from 'zod';
+import { runner } from './run.js';
+import { setup } from './setup.js';
+const run = promisify(execFile);
+export const machine = {
+    home() {
+        return process.env.CRAFTSPACE_CLI_HOME ?? path.join(os.homedir(), '.craftspace');
+    },
+    async login({ token, url, install }) {
+        const answer = await call({
+            url,
+            token,
+            method: 'POST',
+            path: '/api/machines/login',
+            body: {
+                name: os.hostname().split('.')[0] ?? 'machine',
+                platform: `${process.platform}-${process.arch}`,
+                sshUser: os.userInfo().username,
+                cores: os.cpus().length,
+                memoryGb: Math.max(1, Math.round(os.totalmem() / 1024 ** 3)),
+                cli: CLI_VERSION,
+                publicKey: await ensureKey(),
+            },
+            schema: MachineLoginResponseSchema,
+        });
+        await mkdir(machine.home(), { recursive: true, mode: 0o700 });
+        await writeFile(configPath(), JSON.stringify({ url, machineId: answer.machine.id }, null, 2), { mode: 0o600 });
+        await writeFile(tokenPath(), token, { mode: 0o600 });
+        await writeAgentConfigs({ url, token, writes: answer.write });
+        await installService();
+        probed = {
+            at: Date.now(),
+            tools: await setup.run({ install, rewire, say: (line) => process.stdout.write(`${line}\n`) }),
+        };
+        return answer.machine;
+    },
+    async status() {
+        const config = await readConfig();
+        if (!config)
+            return null;
+        const token = await readToken();
+        if (!token)
+            return null;
+        const found = await call({ url: config.url, token, method: 'GET', path: '/api/machines/me', schema: MachineSchema });
+        return { machine: found, url: config.url };
+    },
+    async beatOnce() {
+        const { url, token } = await requireSignedIn();
+        const answer = await call({
+            url,
+            token,
+            method: 'POST',
+            path: '/api/machines/beat',
+            body: {
+                cli: CLI_VERSION,
+                ...load(),
+                sessions: await readSessions(),
+                runs: drainReports(),
+                tools: await tools(),
+                sshUser: os.userInfo().username,
+            },
+            schema: MachineBeatResponseSchema,
+        });
+        await writeAuthorizedKeys(answer.authorizedKeys);
+        for (const work of answer.work) {
+            if (running.has(work.id))
+                continue;
+            running.add(work.id);
+            void runner
+                .unattended({ work, onProgress: report })
+                .then(report)
+                .catch((error) => report({ id: work.id, state: 'failed', output: messageOf(error) }))
+                .finally(() => running.delete(work.id));
+        }
+        return running.size > 0 || answer.work.length > 0;
+    },
+    async beatForever() {
+        let failures = 0;
+        let busy = false;
+        for (;;) {
+            try {
+                busy = await machine.beatOnce();
+                failures = 0;
+            }
+            catch (error) {
+                failures += 1;
+                process.stderr.write(`beat failed: ${messageOf(error)}\n`);
+            }
+            await new Promise((resolve) => setTimeout(resolve, nextDelayMs(failures, busy)));
+        }
+    },
+    async run({ argv, on }) {
+        if (on === undefined)
+            return runHere(argv);
+        return runThere({ argv, on });
+    },
+    async logout() {
+        const config = await readConfig();
+        const token = await readToken();
+        if (config && token) {
+            await call({ url: config.url, token, method: 'POST', path: '/api/machines/logout', schema: z.object({}) }).catch(() => undefined);
+        }
+        await removeAgentConfigs();
+        await uninstallService();
+        await rm(machine.home(), { recursive: true, force: true });
+    },
+};
+async function requireSignedIn() {
+    const config = await readConfig();
+    const token = await readToken();
+    if (!config || !token)
+        throw new Error('This machine is not signed in. Run: craftspace login --token <token>');
+    return { url: config.url, token };
+}
+async function runHere(argv) {
+    const id = `local-${Date.now().toString(36)}`;
+    await writeSession({ id, state: 'working', title: argv.join(' ').slice(0, 200) });
+    try {
+        return await runner.attended(argv);
+    }
+    finally {
+        await clearSession(id);
+    }
+}
+async function runThere({ argv, on }) {
+    const { url, token } = await requireSignedIn();
+    const target = await machineNamed({ url, token, name: on });
+    let run = await call({
+        url,
+        token,
+        method: 'POST',
+        path: `/api/machines/${target.id}/runs`,
+        body: { argv },
+        schema: MachineRunSchema,
+    });
+    process.stdout.write(`${target.name} · queued ${run.id}\n\n`);
+    let printed = 0;
+    for (;;) {
+        if (run.output.length > printed) {
+            process.stdout.write(run.output.slice(printed));
+            printed = run.output.length;
+        }
+        if (run.state === 'done')
+            return 0;
+        if (run.state === 'failed')
+            return run.exitCode ?? 1;
+        if (run.state === 'needs_input') {
+            process.stdout.write(`\n${target.name} is asking: ${run.question ?? 'it needs a decision'}\n> `);
+            const reply = await readStdinLine();
+            if (reply === null)
+                return 130;
+            run = await call({
+                url,
+                token,
+                method: 'POST',
+                path: `/api/machines/runs/${run.id}/answer`,
+                body: { text: reply },
+                schema: MachineRunSchema,
+            });
+            printed = run.output.length;
+            continue;
+        }
+        await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL_MS));
+        run = await readRun({ url, token, machineId: target.id, runId: run.id });
+    }
+}
+async function readRun({ url, token, machineId, runId, }) {
+    const answer = await call({
+        url,
+        token,
+        method: 'GET',
+        path: `/api/machines/${machineId}/runs`,
+        schema: MachineRunsResponseSchema,
+    });
+    const found = answer.runs.find((candidate) => candidate.id === runId);
+    if (found === undefined)
+        throw new Error(`Run ${runId} is gone.`);
+    return found;
+}
+async function machineNamed({ url, token, name, }) {
+    const answer = await call({ url, token, method: 'GET', path: '/api/machines', schema: MachinesResponseSchema });
+    const found = answer.machines.find((candidate) => candidate.name === name || candidate.id === name);
+    if (found === undefined) {
+        throw new Error(`No workstation called ${name}. This team has: ${answer.machines.map((m) => m.name).join(', ')}`);
+    }
+    return found;
+}
+function readStdinLine() {
+    return new Promise((resolve) => {
+        let buffer = '';
+        process.stdin.setEncoding('utf8');
+        const done = (line) => {
+            process.stdin.off('data', onData);
+            process.stdin.off('end', onEnd);
+            process.stdin.pause();
+            resolve(line.trim() === '' ? null : line.trim());
+        };
+        const onData = (chunk) => {
+            buffer += chunk;
+            const at = buffer.indexOf('\n');
+            if (at !== -1)
+                done(buffer.slice(0, at));
+        };
+        const onEnd = () => done(buffer);
+        process.stdin.on('data', onData);
+        process.stdin.on('end', onEnd);
+        process.stdin.resume();
+    });
+}
+async function tools() {
+    if (probed !== null && Date.now() - probed.at < PROBE_EVERY_MS)
+        return probed.tools;
+    const found = await setup.run({ install: process.env.CRAFTSPACE_NO_INSTALL !== '1', rewire });
+    probed = { at: Date.now(), tools: found };
+    return found;
+}
+async function rewire() {
+    const { url, token } = await requireSignedIn();
+    await writeAgentConfigs({ url, token, writes: [] });
+}
+function report(next) {
+    reports.set(next.id, next);
+}
+function drainReports() {
+    const pending = [...reports.values()];
+    for (const item of pending)
+        if (item.state !== 'running')
+            reports.delete(item.id);
+    return pending;
+}
+async function call({ url, token, method, path: route, body, schema, }) {
+    const response = await fetch(`${url}${route}`, {
+        method,
+        headers: {
+            authorization: `Bearer ${token}`,
+            ...(body === undefined ? {} : { 'content-type': 'application/json' }),
+        },
+        ...(body === undefined ? {} : { body: JSON.stringify(body) }),
+        signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS),
+    });
+    if (!response.ok)
+        throw new Error(`${route} answered ${response.status}`);
+    return schema.parse(await response.json());
+}
+async function ensureKey() {
+    const priv = path.join(machine.home(), 'id_ed25519');
+    const pub = `${priv}.pub`;
+    const existing = await readFile(pub, 'utf8').catch(() => null);
+    if (existing !== null)
+        return existing.trim();
+    await mkdir(machine.home(), { recursive: true, mode: 0o700 });
+    await run('ssh-keygen', ['-t', 'ed25519', '-N', '', '-q', '-f', priv, '-C', `craftspace-${os.hostname()}`]);
+    return (await readFile(pub, 'utf8')).trim();
+}
+async function readConfig() {
+    const raw = await readFile(configPath(), 'utf8').catch(() => null);
+    if (raw === null)
+        return null;
+    return ConfigSchema.parse(JSON.parse(raw));
+}
+async function readToken() {
+    const raw = await readFile(tokenPath(), 'utf8').catch(() => null);
+    return raw === null ? null : raw.trim();
+}
+async function readSessions() {
+    const dir = path.join(machine.home(), 'sessions');
+    const names = await readdir(dir).catch(() => []);
+    const sessions = [];
+    for (const name of names.filter((entry) => entry.endsWith('.json'))) {
+        const raw = await readFile(path.join(dir, name), 'utf8').catch(() => null);
+        if (raw === null)
+            continue;
+        const parsed = MachineSessionSchema.safeParse(JSON.parse(raw));
+        if (parsed.success)
+            sessions.push(parsed.data);
+    }
+    return sessions.slice(0, MAX_REPORTED_SESSIONS);
+}
+// Only the block between our markers is ours. Everything a person put in this file by hand is left exactly
+// where it was, because the fastest way to lock a team out of its own box is to rewrite this file wholesale.
+async function writeAuthorizedKeys(keys) {
+    const target = path.join(os.homedir(), '.ssh', 'authorized_keys');
+    const current = await readFile(target, 'utf8').catch(() => '');
+    const before = current.split(KEYS_BEGIN)[0] ?? '';
+    const after = current.includes(KEYS_END) ? (current.split(KEYS_END)[1] ?? '') : '';
+    const block = keys.length === 0 ? '' : `${KEYS_BEGIN}\n${keys.join('\n')}\n${KEYS_END}\n`;
+    const next = `${trimEnd(before)}${trimEnd(before) === '' ? '' : '\n'}${block}${after.replace(/^\n/, '')}`;
+    if (next === current)
+        return;
+    await mkdir(path.dirname(target), { recursive: true, mode: 0o700 });
+    await writeFile(target, next, { mode: 0o600 });
+}
+function trimEnd(text) {
+    return text.replace(/\s+$/, '');
+}
+async function writeSession(session) {
+    const dir = path.join(machine.home(), 'sessions');
+    await mkdir(dir, { recursive: true, mode: 0o700 });
+    await writeFile(path.join(dir, `${session.id}.json`), JSON.stringify(session), { mode: 0o600 });
+}
+async function clearSession(id) {
+    await rm(path.join(machine.home(), 'sessions', `${id}.json`), { force: true });
+}
+async function writeAgentConfigs({ url, token, writes, }) {
+    const planned = writes.length > 0 ? writes : defaultWrites({ url, token });
+    const owned = [];
+    for (const write of planned) {
+        const target = expand(write.path);
+        await mkdir(path.dirname(target), { recursive: true });
+        const current = await readFile(target, 'utf8').catch(() => null);
+        if (current !== null)
+            await writeFile(`${target}.craftspace-backup`, current, { flag: 'wx' }).catch(() => undefined);
+        const merged = mergeInto(current === null ? {} : JSON.parse(current), write.contents);
+        await writeFile(target, `${JSON.stringify(merged, null, 2)}\n`, { mode: 0o600 });
+        owned.push(target);
+    }
+    await writeFile(ownedPath(), JSON.stringify({ paths: owned }, null, 2));
+}
+function mergeInto(current, incoming) {
+    const merged = { ...current };
+    for (const [key, value] of Object.entries(incoming)) {
+        const existing = merged[key];
+        merged[key] =
+            isPlainObject(existing) && isPlainObject(value) ? mergeInto(existing, value) : value;
+    }
+    return merged;
+}
+function isPlainObject(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function defaultWrites({ url, token }) {
+    const server = { craftspace: { type: 'http', url: `${url}/mcp`, headers: { Authorization: `Bearer ${token}` } } };
+    return [{ path: '~/.mcp.json', contents: { mcpServers: server } }];
+}
+async function removeAgentConfigs() {
+    const raw = await readFile(ownedPath(), 'utf8').catch(() => null);
+    if (raw === null)
+        return;
+    const owned = OwnedSchema.parse(JSON.parse(raw));
+    for (const target of owned.paths) {
+        const current = await readFile(target, 'utf8').catch(() => null);
+        if (current === null)
+            continue;
+        const parsed = JSON.parse(current);
+        const servers = parsed.mcpServers;
+        if (isPlainObject(servers))
+            delete servers.craftspace;
+        if (await weCreated(target)) {
+            await rm(target, { force: true });
+            continue;
+        }
+        await writeFile(target, `${JSON.stringify(parsed, null, 2)}\n`);
+    }
+}
+async function weCreated(target) {
+    const backup = await readFile(`${target}.craftspace-backup`, 'utf8').catch(() => null);
+    return backup === null;
+}
+async function installService() {
+    if (process.env.CRAFTSPACE_NO_SERVICE === '1') {
+        process.stdout.write('Skipping the service. Run the beat yourself with: craftspace daemon\n');
+        return;
+    }
+    if (process.platform === 'linux') {
+        const dir = path.join(os.homedir(), '.config', 'systemd', 'user');
+        await mkdir(dir, { recursive: true });
+        await writeFile(path.join(dir, `${SERVICE_NAME}.service`), systemdUnit());
+        await run('systemctl', ['--user', 'daemon-reload']).catch(() => undefined);
+        await run('systemctl', ['--user', 'enable', '--now', SERVICE_NAME]).catch(() => undefined);
+        return;
+    }
+    if (process.platform === 'darwin') {
+        const target = path.join(os.homedir(), 'Library', 'LaunchAgents', `${LAUNCH_LABEL}.plist`);
+        await mkdir(path.dirname(target), { recursive: true });
+        await writeFile(target, launchdPlist());
+        await run('launchctl', ['unload', target]).catch(() => undefined);
+        await run('launchctl', ['load', target]).catch(() => undefined);
+    }
+}
+async function uninstallService() {
+    if (process.platform === 'linux') {
+        await run('systemctl', ['--user', 'disable', '--now', SERVICE_NAME]).catch(() => undefined);
+        await rm(path.join(os.homedir(), '.config', 'systemd', 'user', `${SERVICE_NAME}.service`), { force: true });
+        return;
+    }
+    if (process.platform === 'darwin') {
+        const target = path.join(os.homedir(), 'Library', 'LaunchAgents', `${LAUNCH_LABEL}.plist`);
+        await run('launchctl', ['unload', target]).catch(() => undefined);
+        await rm(target, { force: true });
+    }
+}
+function systemdUnit() {
+    return [
+        '[Unit]',
+        'Description=Craftspace machine',
+        '',
+        '[Service]',
+        `ExecStart=${process.execPath} ${entryPath()} daemon`,
+        'Restart=always',
+        'RestartSec=5',
+        '',
+        '[Install]',
+        'WantedBy=default.target',
+        '',
+    ].join('\n');
+}
+function launchdPlist() {
+    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>${LAUNCH_LABEL}</string>
+  <key>ProgramArguments</key>
+  <array><string>${process.execPath}</string><string>${entryPath()}</string><string>daemon</string></array>
+  <key>RunAtLoad</key><true/>
+  <key>KeepAlive</key><true/>
+</dict>
+</plist>
+`;
+}
+function entryPath() {
+    return path.join(path.dirname(new URL(import.meta.url).pathname), 'index.js');
+}
+function expand(target) {
+    return target.startsWith('~/') ? path.join(os.homedir(), target.slice(2)) : target;
+}
+function configPath() {
+    return path.join(machine.home(), 'config.json');
+}
+function tokenPath() {
+    return path.join(machine.home(), 'token');
+}
+function ownedPath() {
+    return path.join(machine.home(), 'owned.json');
+}
+function load() {
+    const cores = Math.max(1, os.cpus().length);
+    const busy = Math.min(100, ((os.loadavg()[0] ?? 0) / cores) * 100);
+    const used = ((os.totalmem() - os.freemem()) / os.totalmem()) * 100;
+    return { cpuPercent: Math.round(busy), memoryPercent: Math.round(used) };
+}
+export function nextDelayMs(failures, busy = false) {
+    if (failures > 0) {
+        const backoff = Math.min(MAX_BACKOFF_MS, MACHINE_BEAT_INTERVAL_MS * 2 ** failures);
+        return Math.round(backoff * (0.85 + Math.random() * 0.3));
+    }
+    const base = busy ? MACHINE_BEAT_BUSY_INTERVAL_MS : MACHINE_BEAT_INTERVAL_MS;
+    return Math.round(base * (0.85 + Math.random() * 0.3));
+}
+function messageOf(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+const ConfigSchema = z.object({ url: z.string(), machineId: z.string() });
+const OwnedSchema = z.object({ paths: z.array(z.string()) });
+const SERVICE_NAME = 'craftspace';
+const LAUNCH_LABEL = 'app.craftspace.machine';
+const REQUEST_TIMEOUT_MS = 15_000;
+const MAX_REPORTED_SESSIONS = 50;
+const MAX_BACKOFF_MS = 120_000;
+const KEYS_BEGIN = '# craftspace begin';
+const KEYS_END = '# craftspace end';
+const POLL_INTERVAL_MS = 1_000;
+const PROBE_EVERY_MS = 300_000;
+let probed = null;
+const reports = new Map();
+const running = new Set();

package/dist/probe.d.ts

@@ -0,0 +1,7 @@
+import type { MachineTool } from '@craftspace/shared';
+export declare const probe: {
+    tools({ mcpPath }?: {
+        mcpPath?: string;
+    }): Promise<MachineTool[]>;
+};
+export declare function githubUser(hostsYml: string): string | null;

package/dist/probe.js

@@ -0,0 +1,102 @@
+import { execFile } from 'node:child_process';
+import net from 'node:net';
+import { access, readFile } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { promisify } from 'node:util';
+const run = promisify(execFile);
+export const probe = {
+    async tools({ mcpPath = path.join(os.homedir(), '.mcp.json') } = {}) {
+        const [brain, claude, codex, git, chrome, ssh] = await Promise.all([
+            brainWired(mcpPath),
+            version({ id: 'claude', command: 'claude' }),
+            version({ id: 'codex', command: 'codex' }),
+            gitAndGithub(),
+            chromeInstalled(),
+            sshListening(),
+        ]);
+        return [brain, claude, codex, git, chrome, ssh];
+    },
+};
+async function brainWired(mcpPath) {
+    const raw = await readFile(mcpPath, 'utf8').catch(() => null);
+    if (raw === null)
+        return { id: 'brain', ok: false, detail: `no ${short(mcpPath)} on this machine` };
+    const parsed = JSON.parse(raw);
+    const servers = parsed?.mcpServers;
+    const wired = servers !== undefined && servers !== null && 'craftspace' in servers;
+    return {
+        id: 'brain',
+        ok: wired,
+        detail: wired ? short(mcpPath) : `${short(mcpPath)} has no craftspace entry`,
+    };
+}
+async function version({ id, command }) {
+    const found = await firstLine(command, ['--version']);
+    if (typeof found === 'string')
+        return { id, ok: true, detail: found };
+    return { id, ok: false, detail: found === 'absent' ? 'not installed' : 'installed, but it will not report a version' };
+}
+async function gitAndGithub() {
+    const git = await firstLine('git', ['--version']);
+    if (typeof git !== 'string')
+        return { id: 'git', ok: false, detail: 'git is not installed' };
+    const gh = await firstLine('gh', ['--version']);
+    if (typeof gh !== 'string')
+        return { id: 'git', ok: false, detail: `${git} · the GitHub CLI is not installed yet` };
+    const account = await githubAccount();
+    return {
+        id: 'git',
+        ok: account !== null,
+        detail: account === null
+            ? `${git} · ${gh}, run gh auth login on this machine`
+            : `${git} · ${gh}, signed in as ${account}`,
+    };
+}
+async function githubAccount() {
+    const raw = await readFile(path.join(os.homedir(), '.config', 'gh', 'hosts.yml'), 'utf8').catch(() => null);
+    return raw === null ? null : githubUser(raw);
+}
+export function githubUser(hostsYml) {
+    return /^ {4}user: *(\S+) *$/m.exec(hostsYml)?.[1] ?? null;
+}
+async function chromeInstalled() {
+    for (const command of [...MAC_CHROME, ...LINUX_CHROME]) {
+        const found = await firstLine(command, ['--version']);
+        if (typeof found === 'string')
+            return { id: 'chrome', ok: true, detail: found };
+    }
+    return { id: 'chrome', ok: false, detail: 'not installed yet, so browser runs will fail' };
+}
+function sshListening() {
+    return new Promise((resolve) => {
+        const socket = net.connect({ host: '127.0.0.1', port: 22 });
+        const answer = (ok, detail) => {
+            socket.destroy();
+            resolve({ id: 'ssh', ok, detail });
+        };
+        socket.setTimeout(SSH_PROBE_TIMEOUT_MS);
+        socket.on('connect', () => answer(true, 'sshd is listening on port 22'));
+        socket.on('timeout', () => answer(false, 'nothing answered on port 22'));
+        socket.on('error', () => answer(false, 'sshd is not running, so nobody can ssh in'));
+    });
+}
+async function firstLine(command, args) {
+    if (command.includes('/')) {
+        const reachable = await access(command).then(() => true, () => false);
+        if (!reachable)
+            return 'absent';
+    }
+    const answer = await run(command, args, { timeout: PROBE_TIMEOUT_MS }).catch((thrown) => thrown);
+    if (answer instanceof Error)
+        return answer.code === 'ENOENT' ? 'absent' : 'broken';
+    const line = answer.stdout.split('\n')[0]?.trim() ?? '';
+    return line === '' ? 'broken' : line.slice(0, 200);
+}
+function short(target) {
+    return target.startsWith(os.homedir()) ? `~${target.slice(os.homedir().length)}` : target;
+}
+const MAC_CHROME = ['/Applications/Google Chrome.app/Contents/MacOS/Google Chrome'];
+const LINUX_CHROME = ['google-chrome', 'google-chrome-stable', 'chromium'];
+const PROBE_TIMEOUT_MS = 5_000;
+const SSH_PROBE_TIMEOUT_MS = 1_500;

package/dist/run.d.ts

@@ -0,0 +1,9 @@
+import { type MachineRunReport, type MachineWork } from '@craftspace/shared';
+export declare const runner: {
+    attended(argv: string[]): Promise<number>;
+    unattended({ work, onProgress, }: {
+        work: MachineWork;
+        onProgress?: (report: MachineRunReport) => void;
+    }): Promise<MachineRunReport>;
+};
+export declare function headlessArgv(work: MachineWork): string[];