agent-device-lab 0.0.0-stage → 0.3.1

package/dist/core/zip.js

@@ -0,0 +1,264 @@
+import { deflateRawSync, inflateRawSync } from 'node:zlib';
+export class ZipError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'ZipError';
+    }
+}
+export const ZIP_MAX_ENTRIES = 20_000;
+export const ZIP_MAX_TOTAL_BYTES = 1024 ** 3;
+const SIG_LOCAL = 0x04034b50;
+const SIG_CENTRAL = 0x02014b50;
+const SIG_EOCD = 0x06054b50;
+const SIG_ZIP64_LOCATOR = 0x07064b50;
+const SIG_DESCRIPTOR = 0x08074b50;
+let crcTable;
+function table() {
+    if (crcTable)
+        return crcTable;
+    const t = new Uint32Array(256);
+    for (let n = 0; n < 256; n++) {
+        let c = n;
+        for (let k = 0; k < 8; k++)
+            c = c & 1 ? 0xedb88320 ^ (c >>> 1) : c >>> 1;
+        t[n] = c >>> 0;
+    }
+    crcTable = t;
+    return t;
+}
+export function crc32(data) {
+    const t = table();
+    let c = 0xffffffff;
+    for (let i = 0; i < data.length; i++)
+        c = t[(c ^ data[i]) & 0xff] ^ (c >>> 8);
+    return (c ^ 0xffffffff) >>> 0;
+}
+/** Throws for names that could escape an extraction directory or that are ambiguous. */
+export function checkZipName(name) {
+    if (name.length === 0)
+        throw new ZipError('zip entry with an empty name');
+    if (name.includes('\0'))
+        throw new ZipError('zip entry name contains a NUL byte');
+    if (name.includes('\\'))
+        throw new ZipError('zip entry name contains a backslash');
+    if (name.startsWith('/') || /^[A-Za-z]:/.test(name))
+        throw new ZipError('zip entry name is an absolute path');
+    if (name.split('/').includes('..'))
+        throw new ZipError('zip entry name contains a ".." segment');
+}
+export function readZip(buf) {
+    if (buf.length < 22)
+        throw new ZipError('not a zip archive (too short)');
+    // End of central directory: the last record whose comment length reaches exactly to the end of the file.
+    let eocd = -1;
+    for (let i = buf.length - 22; i >= Math.max(0, buf.length - 22 - 0xffff); i--) {
+        if (buf.readUInt32LE(i) === SIG_EOCD && i + 22 + buf.readUInt16LE(i + 20) === buf.length) {
+            eocd = i;
+            break;
+        }
+    }
+    if (eocd < 0)
+        throw new ZipError('not a zip archive (no end of central directory)');
+    if (eocd >= 20 && buf.readUInt32LE(eocd - 20) === SIG_ZIP64_LOCATOR)
+        throw new ZipError('zip64 archives are not supported');
+    const diskNo = buf.readUInt16LE(eocd + 4);
+    const cdDisk = buf.readUInt16LE(eocd + 6);
+    const countHere = buf.readUInt16LE(eocd + 8);
+    const count = buf.readUInt16LE(eocd + 10);
+    const cdSize = buf.readUInt32LE(eocd + 12);
+    const cdOffset = buf.readUInt32LE(eocd + 16);
+    if (diskNo !== 0 || cdDisk !== 0 || countHere !== count)
+        throw new ZipError('multi-disk zip archives are not supported');
+    if (count === 0xffff || cdSize === 0xffffffff || cdOffset === 0xffffffff)
+        throw new ZipError('zip64 archives are not supported');
+    if (count > ZIP_MAX_ENTRIES)
+        throw new ZipError(`zip has more than ${ZIP_MAX_ENTRIES} entries`);
+    if (cdOffset + cdSize > eocd)
+        throw new ZipError('central directory is out of bounds');
+    const records = [];
+    const seen = new Set();
+    let p = cdOffset;
+    for (let n = 0; n < count; n++) {
+        if (p + 46 > cdOffset + cdSize || buf.readUInt32LE(p) !== SIG_CENTRAL)
+            throw new ZipError('bad central directory record');
+        const flags = buf.readUInt16LE(p + 8);
+        const method = buf.readUInt16LE(p + 10);
+        const crc = buf.readUInt32LE(p + 16);
+        const csize = buf.readUInt32LE(p + 20);
+        const usize = buf.readUInt32LE(p + 24);
+        const nameLen = buf.readUInt16LE(p + 28);
+        const extraLen = buf.readUInt16LE(p + 30);
+        const commentLen = buf.readUInt16LE(p + 32);
+        const disk = buf.readUInt16LE(p + 34);
+        const offset = buf.readUInt32LE(p + 42);
+        const end = p + 46 + nameLen + extraLen + commentLen;
+        if (end > cdOffset + cdSize)
+            throw new ZipError('central directory record is out of bounds');
+        if (flags & 0x1 || flags & 0x40 || flags & 0x2000)
+            throw new ZipError('encrypted zip entries are not supported');
+        if (method !== 0 && method !== 8)
+            throw new ZipError(`unsupported zip compression method ${method}`);
+        if (csize === 0xffffffff || usize === 0xffffffff || offset === 0xffffffff || disk !== 0)
+            throw new ZipError('zip64 archives are not supported');
+        // Extra fields: a zip64 field means the sizes above are not the real ones.
+        let x = p + 46 + nameLen;
+        const xEnd = x + extraLen;
+        while (x + 4 <= xEnd) {
+            const id = buf.readUInt16LE(x);
+            const len = buf.readUInt16LE(x + 2);
+            if (id === 0x0001 || id === 0x9901)
+                throw new ZipError('zip64 or encrypted extra fields are not supported');
+            x += 4 + len;
+        }
+        const nameBytes = buf.subarray(p + 46, p + 46 + nameLen);
+        let name = nameBytes.toString('utf8');
+        const dir = name.endsWith('/');
+        if (dir)
+            name = name.slice(0, -1);
+        checkZipName(name);
+        if (seen.has(name))
+            throw new ZipError('duplicate zip entry name');
+        seen.add(name);
+        if (method === 0 && csize !== usize)
+            throw new ZipError('stored zip entry has mismatched sizes');
+        records.push({ name, method, flags, crc, csize, usize, offset, nameBytes: Buffer.from(nameBytes), dir });
+        p = end;
+    }
+    if (p !== cdOffset + cdSize)
+        throw new ZipError('central directory size mismatch');
+    const extents = [];
+    const entries = [];
+    let total = 0;
+    for (const r of records) {
+        if (r.offset + 30 > cdOffset || buf.readUInt32LE(r.offset) !== SIG_LOCAL)
+            throw new ZipError('bad local header');
+        const lflags = buf.readUInt16LE(r.offset + 6);
+        const lmethod = buf.readUInt16LE(r.offset + 8);
+        const lcrc = buf.readUInt32LE(r.offset + 14);
+        const lcsize = buf.readUInt32LE(r.offset + 18);
+        const lusize = buf.readUInt32LE(r.offset + 22);
+        const lnameLen = buf.readUInt16LE(r.offset + 26);
+        const lextraLen = buf.readUInt16LE(r.offset + 28);
+        if (lmethod !== r.method)
+            throw new ZipError('local header disagrees with the central directory (method)');
+        if (lflags & 0x1)
+            throw new ZipError('encrypted zip entries are not supported');
+        const nameStart = r.offset + 30;
+        if (nameStart + lnameLen > cdOffset || !buf.subarray(nameStart, nameStart + lnameLen).equals(r.nameBytes)) {
+            throw new ZipError('local header disagrees with the central directory (name)');
+        }
+        const dataStart = nameStart + lnameLen + lextraLen;
+        const dataEnd = dataStart + r.csize;
+        if (dataEnd > cdOffset)
+            throw new ZipError('zip entry data is out of bounds');
+        let entryEnd = dataEnd;
+        if (lflags & 0x8) {
+            // Sizes and CRC follow the data; they must agree with the central directory.
+            let d = dataEnd;
+            if (d + 4 <= cdOffset && buf.readUInt32LE(d) === SIG_DESCRIPTOR)
+                d += 4;
+            if (d + 12 > cdOffset)
+                throw new ZipError('missing data descriptor');
+            if (buf.readUInt32LE(d) !== r.crc || buf.readUInt32LE(d + 4) !== r.csize || buf.readUInt32LE(d + 8) !== r.usize) {
+                throw new ZipError('data descriptor disagrees with the central directory');
+            }
+            entryEnd = d + 12;
+        }
+        else if (lcrc !== r.crc || lcsize !== r.csize || lusize !== r.usize) {
+            throw new ZipError('local header disagrees with the central directory (sizes)');
+        }
+        extents.push([r.offset, entryEnd]);
+        if (r.dir) {
+            if (r.usize !== 0)
+                throw new ZipError('zip directory entry has content');
+            continue;
+        }
+        total += r.usize;
+        if (total > ZIP_MAX_TOTAL_BYTES)
+            throw new ZipError('zip expands to more than 1 GiB');
+        const raw = buf.subarray(dataStart, dataEnd);
+        let data;
+        if (r.method === 0)
+            data = Buffer.from(raw);
+        else {
+            try {
+                data = inflateRawSync(raw, { maxOutputLength: Math.max(r.usize, 1) });
+            }
+            catch {
+                throw new ZipError('zip entry cannot be inflated (corrupt or larger than declared)');
+            }
+        }
+        if (data.length !== r.usize)
+            throw new ZipError('zip entry size does not match its header');
+        if (crc32(data) !== r.crc)
+            throw new ZipError('zip entry fails its CRC check');
+        entries.push({ name: r.name, data });
+    }
+    extents.sort((a, b) => a[0] - b[0]);
+    for (let i = 1; i < extents.length; i++) {
+        if (extents[i][0] < extents[i - 1][1])
+            throw new ZipError('zip entries overlap');
+    }
+    return entries;
+}
+export function writeZip(entries) {
+    if (entries.length > 0xfffe)
+        throw new ZipError('too many zip entries to write');
+    const seen = new Set();
+    const parts = [];
+    const central = [];
+    let offset = 0;
+    for (const e of entries) {
+        checkZipName(e.name);
+        if (seen.has(e.name))
+            throw new ZipError('duplicate zip entry name');
+        seen.add(e.name);
+        const name = Buffer.from(e.name, 'utf8');
+        const compressed = deflateRawSync(e.data, { level: 6 });
+        const crc = crc32(e.data);
+        if (e.data.length >= 0xffffffff || compressed.length >= 0xffffffff || offset >= 0xffffffff)
+            throw new ZipError('zip entry too large to write');
+        const local = Buffer.alloc(30);
+        local.writeUInt32LE(SIG_LOCAL, 0);
+        local.writeUInt16LE(20, 4); // version needed
+        local.writeUInt16LE(0x0800, 6); // UTF-8 names
+        local.writeUInt16LE(8, 8); // deflate
+        local.writeUInt16LE(0, 10); // time
+        local.writeUInt16LE(0x0021, 12); // date: 1980-01-01, fixed so output is reproducible
+        local.writeUInt32LE(crc, 14);
+        local.writeUInt32LE(compressed.length, 18);
+        local.writeUInt32LE(e.data.length, 22);
+        local.writeUInt16LE(name.length, 26);
+        local.writeUInt16LE(0, 28);
+        parts.push(local, name, compressed);
+        const cd = Buffer.alloc(46);
+        cd.writeUInt32LE(SIG_CENTRAL, 0);
+        cd.writeUInt16LE((3 << 8) | 20, 4); // made by: unix, 2.0
+        cd.writeUInt16LE(20, 6);
+        cd.writeUInt16LE(0x0800, 8);
+        cd.writeUInt16LE(8, 10);
+        cd.writeUInt16LE(0, 12);
+        cd.writeUInt16LE(0x0021, 14);
+        cd.writeUInt32LE(crc, 16);
+        cd.writeUInt32LE(compressed.length, 20);
+        cd.writeUInt32LE(e.data.length, 24);
+        cd.writeUInt16LE(name.length, 28);
+        cd.writeUInt16LE(0, 30);
+        cd.writeUInt16LE(0, 32);
+        cd.writeUInt16LE(0, 34);
+        cd.writeUInt16LE(0, 36);
+        cd.writeUInt32LE(((0o100644 << 16) >>> 0), 38);
+        cd.writeUInt32LE(offset, 42);
+        central.push(cd, name);
+        offset += local.length + name.length + compressed.length;
+    }
+    const cdBuf = Buffer.concat(central);
+    const eocd = Buffer.alloc(22);
+    eocd.writeUInt32LE(SIG_EOCD, 0);
+    eocd.writeUInt16LE(entries.length, 8);
+    eocd.writeUInt16LE(entries.length, 10);
+    eocd.writeUInt32LE(cdBuf.length, 12);
+    eocd.writeUInt32LE(offset, 16);
+    return Buffer.concat([...parts, cdBuf, eocd]);
+}
+//# sourceMappingURL=zip.js.map

package/dist/daemon/main.js

@@ -0,0 +1,160 @@
+// Long-lived session process. `agentlab start` spawns it detached; later CLI invocations talk to it
+// over a unix socket. It owns the browser, the session and any server it started, and writes an
+// ordered action log to stdout (redirected to .agentlab/daemon.log). Unless started with --no-ui it
+// also serves the live dashboard on 127.0.0.1.
+import { createServer } from 'node:http';
+import { chmodSync, mkdirSync, rmSync } from 'node:fs';
+import { SessionHost, dispatch } from '../core/commands.js';
+import { SessionFeed } from '../core/feed.js';
+import { formatAction, formatClose, formatControlChange, formatHuman, formatService } from '../core/format.js';
+import { identify } from '../core/process-identity.js';
+import { Dashboard } from '../dashboard/server.js';
+import { clearState, paths, writeState } from './state.js';
+const dir = process.argv[2];
+const ui = !process.argv.includes('--no-ui');
+if (!dir) {
+    console.error('usage: daemon <stateDir> [--no-ui]');
+    process.exit(2);
+}
+mkdirSync(dir, { recursive: true, mode: 0o700 });
+const { socket } = paths(dir);
+const ts = () => new Date().toISOString().slice(11, 23);
+const logBlock = (head, body) => {
+    process.stdout.write(`[${ts()}] ${head}\n`);
+    if (body)
+        process.stdout.write(body.split('\n').map((l) => `    ${l}`).join('\n') + '\n');
+};
+/** The service output echoed into daemon.log stops here (env AGENTLAB_DAEMON_ECHO_MAX_BYTES); the service's own log file is capped separately. */
+const echoMax = Number(process.env.AGENTLAB_DAEMON_ECHO_MAX_BYTES) > 0 ? Number(process.env.AGENTLAB_DAEMON_ECHO_MAX_BYTES) : 5 * 1024 * 1024;
+let echoed = 0;
+function echoServerLine(line) {
+    if (echoed > echoMax)
+        return;
+    const text = `[${ts()}] [web] ${line}\n`;
+    echoed += Buffer.byteLength(text);
+    if (echoed > echoMax)
+        process.stdout.write(`[${ts()}] [web] … server output in this log stopped at ${echoMax} bytes; the full output is in the run's service log files\n`);
+    else
+        process.stdout.write(text);
+}
+const state = { pid: process.pid, daemon: identify(process.pid), socket, startedAt: new Date().toISOString() };
+const feed = new SessionFeed();
+function onEvent(e) {
+    feed.apply(e);
+    switch (e.kind) {
+        case 'server-log':
+            echoServerLine(e.line);
+            break;
+        case 'start': {
+            const { session, server, observation } = e.result;
+            state.sessionId = session.id;
+            state.server = { url: server.url, owned: server.owned, pid: server.pid, identity: host.lab.serverIdentity() };
+            state.services = host.lab.serviceRecords();
+            writeState(dir, state);
+            logBlock(`start ${session.id} ${session.device.id} ${session.browser.headed ? 'headed' : 'headless'}; server ${server.owned ? `started pid ${server.pid} (owned)` : 'reused (not owned)'}; route ${observation.route}`);
+            if (e.result.services.length > 1)
+                logBlock('services', e.result.services.map(formatService).join('\n'));
+            break;
+        }
+        case 'observe':
+            logBlock(`observe gen ${e.observation.gen} route ${e.observation.route} controls ${e.observation.controls.length} layout flags ${e.observation.layout.length}`);
+            break;
+        case 'act': {
+            const [head, ...rest] = formatAction(e.result).split('\n');
+            // Keep the log readable: a navigation embeds a full observation, which the log does not need.
+            logBlock(head ?? '', rest.filter((l) => /^(note|changed|console):/.test(l)).join('\n'));
+            break;
+        }
+        case 'control':
+            logBlock(`control: ${formatControlChange(e.change)}`);
+            break;
+        case 'human':
+            logBlock(`person ${formatHuman(e.action)}`);
+            break;
+        case 'refused':
+            logBlock(`${e.command} refused: ${e.error.code}`);
+            break;
+        case 'closed':
+            logBlock(formatClose(e.result));
+            shutdown(0);
+            break;
+    }
+}
+const host = new SessionHost({ stateDir: dir, onEvent, evidenceFrames: ui });
+const dashboard = ui ? await Dashboard.listen({
+    feed, source: () => host.lab,
+    control: (op, by) => host.supervise(op, by),
+    input: (i) => host.lab.humanInput(i),
+}) : undefined;
+if (dashboard) {
+    // Agents get the view-only URL; the person's control URL stays in the owner-only daemon.json (`agentlab ui`).
+    host.dashboardUrl = () => dashboard.viewUrl;
+    state.dashboard = { url: dashboard.url };
+}
+let queue = Promise.resolve();
+let shuttingDown = false;
+const server = createServer((req, res) => {
+    if (req.method !== 'POST' || req.url !== '/rpc') {
+        res.writeHead(404).end();
+        return;
+    }
+    let body = '';
+    req.setEncoding('utf8');
+    req.on('data', (c) => { body += c; });
+    req.on('end', () => {
+        // Commands run strictly one at a time against the single page.
+        queue = queue.then(async () => {
+            let response;
+            let command = '?';
+            let args;
+            try {
+                ({ command, args } = JSON.parse(body));
+            }
+            catch { /* dispatch reports the unknown command */ }
+            const out = await dispatch(host, 'cli', command, args);
+            if (out.ok) {
+                response = { ok: true, result: out.output.result, text: out.output.text };
+            }
+            else {
+                response = { ok: false, error: out.error };
+                logBlock(`${command} failed: ${out.error.code}: ${out.error.message}`);
+            }
+            res.writeHead(200, { 'content-type': 'application/json' }).end(JSON.stringify(response));
+            if (command === 'start' && !response.ok)
+                shutdown(1);
+        });
+    });
+});
+function shutdown(code) {
+    if (shuttingDown)
+        return;
+    shuttingDown = true;
+    // Give in-flight responses (and the dashboard's final status) a moment to flush first.
+    setTimeout(async () => {
+        server.close();
+        clearState(dir);
+        await dashboard?.close().catch(() => undefined);
+        process.exit(code);
+    }, 100);
+}
+for (const sig of ['SIGINT', 'SIGTERM', 'SIGHUP']) {
+    process.on(sig, () => {
+        logBlock(`received ${sig}`);
+        void host.lab.close(`daemon received ${sig}`).then(() => shutdown(0));
+    });
+}
+process.on('uncaughtException', (err) => {
+    logBlock(`uncaught error: ${err.stack ?? err.message}`);
+    void host.lab.close('daemon crashed').finally(() => shutdown(1));
+});
+rmSync(socket, { force: true });
+// Only the owner may connect: bind under a restrictive umask (the fallback path lives in the shared temp
+// directory), then set the mode explicitly.
+const previousUmask = process.umask(0o177);
+server.listen(socket, () => {
+    chmodSync(socket, 0o600);
+    writeState(dir, state);
+    logBlock(`daemon ${process.pid} listening on ${socket}${dashboard ? `; dashboard on ${dashboard.origin}` : ''}`);
+});
+process.umask(previousUmask);
+//# sourceMappingURL=main.js.map

package/dist/daemon/state.js

@@ -0,0 +1,93 @@
+import { createHash } from 'node:crypto';
+import { chmodSync, existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { request } from 'node:http';
+import { homedir, tmpdir } from 'node:os';
+import { basename, join, resolve } from 'node:path';
+import { checkIdentity, identify } from '../core/process-identity.js';
+/**
+ * Where runs, logs and the daemon record live. AGENTLAB_HOME wins. A directory that was initialised
+ * (it has agentlab.json or .agentlab/) keeps them in ./.agentlab; anywhere else they go under the
+ * user's state directory, so running agentlab never litters an unrelated directory.
+ */
+export function stateDir(cwd = process.cwd()) {
+    if (process.env.AGENTLAB_HOME)
+        return resolve(process.env.AGENTLAB_HOME);
+    const local = join(cwd, '.agentlab');
+    if (existsSync(local) || existsSync(join(cwd, 'agentlab.json')))
+        return local;
+    return join(userStateRoot(), 'projects', `${basename(cwd).replace(/[^\w.-]/g, '_') || 'root'}-${createHash('sha1').update(cwd).digest('hex').slice(0, 10)}`);
+}
+/** $XDG_STATE_HOME/agentlab, else ~/.local/state/agentlab. `rm -rf` of it removes everything the lab kept outside projects. */
+export function userStateRoot() {
+    return join(process.env.XDG_STATE_HOME || join(homedir(), '.local', 'state'), 'agentlab');
+}
+export const paths = (dir) => {
+    const preferred = join(dir, 'daemon.sock');
+    // Unix socket paths are limited to ~107 bytes; fall back to a hashed name in the temp dir.
+    const socket = preferred.length < 100 ? preferred : join(tmpdir(), `agentlab-${createHash('sha1').update(dir).digest('hex').slice(0, 12)}.sock`);
+    return { socket, state: join(dir, 'daemon.json'), log: join(dir, 'daemon.log') };
+};
+export function readState(dir) {
+    try {
+        return JSON.parse(readFileSync(paths(dir).state, 'utf8'));
+    }
+    catch {
+        return undefined;
+    }
+}
+export function writeState(dir, state) {
+    const file = paths(dir).state;
+    writeFileSync(file, JSON.stringify(state, null, 2), { mode: 0o600 });
+    chmodSync(file, 0o600);
+}
+export function clearState(dir) {
+    const p = paths(dir);
+    rmSync(p.state, { force: true });
+    if (existsSync(p.socket))
+        rmSync(p.socket, { force: true });
+}
+const dashboardFile = (dir) => join(dir, 'mcp-dashboard.json');
+export function writeDashboardRecord(dir, url) {
+    mkdirSync(dir, { recursive: true, mode: 0o700 });
+    const record = { url, pid: process.pid, identity: identify(process.pid) };
+    writeFileSync(dashboardFile(dir), JSON.stringify(record, null, 2), { mode: 0o600 });
+    chmodSync(dashboardFile(dir), 0o600);
+}
+export function clearDashboardRecord(dir) {
+    rmSync(dashboardFile(dir), { force: true });
+}
+/** The live MCP server's dashboard record, if its process is still the one that wrote it. */
+export function readDashboardRecord(dir) {
+    try {
+        const r = JSON.parse(readFileSync(dashboardFile(dir), 'utf8'));
+        return checkIdentity(r.identity) === 'same' ? r : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Is the recorded daemon the process currently holding that pid? Records without identity are unverifiable. */
+export function daemonCheck(state) {
+    return checkIdentity(state.daemon);
+}
+export function rpc(socket, command, args = {}) {
+    return new Promise((resolvePromise, reject) => {
+        const body = JSON.stringify({ command, args });
+        const req = request({ socketPath: socket, path: '/rpc', method: 'POST', headers: { 'content-type': 'application/json', 'content-length': Buffer.byteLength(body) } }, (res) => {
+            let data = '';
+            res.setEncoding('utf8');
+            res.on('data', (chunk) => { data += chunk; });
+            res.on('end', () => {
+                try {
+                    resolvePromise(JSON.parse(data));
+                }
+                catch (err) {
+                    reject(err);
+                }
+            });
+        });
+        req.on('error', reject);
+        req.end(body);
+    });
+}
+//# sourceMappingURL=state.js.map

package/dist/dashboard/open.js

@@ -0,0 +1,25 @@
+import { spawn } from 'node:child_process';
+/** Whether a desktop browser can be opened from this process. */
+export function hasDisplay() {
+    if (process.platform === 'darwin' || process.platform === 'win32')
+        return true;
+    return !!(process.env.DISPLAY || process.env.WAYLAND_DISPLAY);
+}
+/** Open a URL in the user's browser without waiting for it. Returns false when there is no display. */
+export function openInBrowser(url) {
+    if (!hasDisplay())
+        return false;
+    const [cmd, args] = process.platform === 'darwin' ? ['open', [url]]
+        : process.platform === 'win32' ? ['cmd', ['/c', 'start', '', url]]
+            : ['xdg-open', [url]];
+    try {
+        const child = spawn(cmd, args, { detached: true, stdio: 'ignore' });
+        child.on('error', () => undefined);
+        child.unref();
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+//# sourceMappingURL=open.js.map