@stage-labs/metro 0.1.0-beta.4 → 0.1.0-beta.41

package/dist/plugin.js

@@ -0,0 +1,82 @@
+import { spawnSync } from 'node:child_process';
+import { existsSync, readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { readToken } from './store.js';
+const MARKETPLACE_REPO = 'bonustrack/metro';
+const PLUGIN_SPEC = 'metro@metro';
+export function installPathFrom(raw) {
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+    if (typeof parsed !== 'object' || parsed === null)
+        return null;
+    const plugins = parsed.plugins;
+    if (typeof plugins !== 'object' || plugins === null)
+        return null;
+    const entries = plugins[PLUGIN_SPEC];
+    if (!Array.isArray(entries))
+        return null;
+    const first = entries[0];
+    return typeof first?.installPath === 'string' ? first.installPath : null;
+}
+export function pluginInstallPath() {
+    const registry = join(homedir(), '.claude', 'plugins', 'installed_plugins.json');
+    let raw;
+    try {
+        raw = readFileSync(registry, 'utf8');
+    }
+    catch {
+        return null;
+    }
+    const path = installPathFrom(raw);
+    if (path === null)
+        return null;
+    return existsSync(join(path, 'bin', 'metro-plugin.mjs')) ? path : null;
+}
+function runClaude(args) {
+    const res = spawnSync('claude', args, { encoding: 'utf8' });
+    if (res.error !== undefined)
+        throw new Error('the `claude` command is not on PATH — install Claude Code first');
+    const output = `${res.stdout ?? ''}${res.stderr ?? ''}`;
+    return { ok: res.status === 0, output };
+}
+const tolerable = (output) => /already|exists|latest version/i.test(output);
+export function syncPluginServers() {
+    const path = pluginInstallPath();
+    if (path === null || readToken() === null)
+        return false;
+    const script = join(path, 'bin', 'metro-plugin.mjs');
+    const refreshed = spawnSync(process.execPath, [script, 'refresh'], {
+        stdio: ['ignore', 'inherit', 'inherit'],
+    });
+    if (refreshed.status !== 0)
+        return false;
+    runClaude(['plugin', 'update', PLUGIN_SPEC]);
+    return true;
+}
+export async function installPlugin() {
+    const added = runClaude(['plugin', 'marketplace', 'add', MARKETPLACE_REPO]);
+    if (!added.ok && !tolerable(added.output)) {
+        process.stderr.write(added.output);
+        return 1;
+    }
+    const installed = runClaude(['plugin', 'install', PLUGIN_SPEC]);
+    if (!installed.ok && !tolerable(installed.output)) {
+        process.stderr.write(installed.output);
+        return 1;
+    }
+    process.stderr.write('Claude Code plugin installed.\n');
+    if (syncPluginServers()) {
+        process.stderr.write('Connector servers loaded — new Claude sessions have them; ' +
+            'run /reload-plugins in any session already open.\n');
+        return 0;
+    }
+    process.stderr.write('Now sign in: metro login (get a code at https://metro.box/#/authorize), ' +
+        'or run /metro:login <code> inside Claude Code.\n');
+    return Promise.resolve(0);
+}

package/dist/prompt.js

@@ -0,0 +1,61 @@
+import { createInterface } from 'node:readline';
+const CTRL_C = '\u0003';
+const BACKSPACE = '\u007f';
+export function askLine(question) {
+    const rl = createInterface({ input: process.stdin, output: process.stderr });
+    return new Promise((resolve) => {
+        rl.question(question, (answer) => {
+            rl.close();
+            resolve(answer.trim());
+        });
+    });
+}
+export function feedSecret(value, chunk) {
+    let out = value;
+    for (const ch of chunk) {
+        if (ch === CTRL_C)
+            return { kind: 'cancelled' };
+        if (ch === '\r' || ch === '\n')
+            return { kind: 'done', value: out };
+        if (ch === BACKSPACE || ch === '\b') {
+            out = out.slice(0, -1);
+            continue;
+        }
+        if (ch >= ' ')
+            out += ch;
+    }
+    return { kind: 'more', value: out };
+}
+export function askSecret(question) {
+    const stdin = process.stdin;
+    if (!stdin.isTTY)
+        return askLine(question);
+    process.stderr.write(question);
+    stdin.setRawMode(true);
+    stdin.resume();
+    stdin.setEncoding('utf8');
+    return new Promise((resolve, reject) => {
+        let value = '';
+        const finish = () => {
+            stdin.setRawMode(false);
+            stdin.pause();
+            stdin.off('data', onData);
+            process.stderr.write('\n');
+        };
+        const onData = (chunk) => {
+            const step = feedSecret(value, chunk);
+            if (step.kind === 'cancelled') {
+                finish();
+                reject(new Error('cancelled'));
+                return;
+            }
+            if (step.kind === 'done') {
+                finish();
+                resolve(step.value.trim());
+                return;
+            }
+            value = step.value;
+        };
+        stdin.on('data', onData);
+    });
+}

package/dist/runtime.js

@@ -0,0 +1,117 @@
+import { spawn, spawnSync } from 'node:child_process';
+import { mkdirSync, readFileSync, writeFileSync, chmodSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { existsSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { metroUrl } from './store.js';
+const AGENT_RE = /^[A-Za-z0-9][A-Za-z0-9_-]{10}$/;
+export const SERVER_ENTRY = join('node_modules', '@metro-labs', 'mcp', 'src', 'server.ts');
+export class MissingRuntime extends Error {
+}
+export function runtimeDir() {
+    const explicit = process.env.METRO_RUNTIME_DIR?.trim();
+    const dir = explicit !== undefined && explicit !== ''
+        ? explicit
+        : join(dirname(dirname(fileURLToPath(import.meta.url))), 'runtime');
+    if (!existsSync(join(dir, SERVER_ENTRY)))
+        throw new MissingRuntime(`no metro daemon at ${dir}. Reinstall with: npm i -g @stage-labs/metro@beta`);
+    return dir;
+}
+export class MissingBun extends Error {
+}
+export function assertAgentId(id) {
+    if (id === undefined || !AGENT_RE.test(id))
+        throw new Error(`'${id ?? ''}' is not an agent id — copy it from the agent's page in the web UI`);
+    return id;
+}
+export function findBun() {
+    const found = spawnSync('bun', ['--version'], { stdio: 'ignore' });
+    if (found.error !== undefined || found.status !== 0)
+        throw new MissingBun('metro start needs Bun, which is not on PATH.\n' +
+            'Install it with:  curl -fsSL https://bun.sh/install | bash');
+    return 'bun';
+}
+function tokenPath(agentId) {
+    const xdg = process.env.XDG_CONFIG_HOME?.trim();
+    const base = xdg === undefined || xdg === '' ? join(homedir(), '.config') : xdg;
+    return join(base, 'metro', `runtime-${agentId}.json`);
+}
+export function readRunToken(agentId) {
+    const fromEnv = process.env.METRO_RUN_TOKEN?.trim();
+    if (fromEnv !== undefined && fromEnv !== '')
+        return fromEnv;
+    try {
+        const parsed = JSON.parse(readFileSync(tokenPath(agentId), 'utf8'));
+        if (typeof parsed.token !== 'string' || parsed.token === '')
+            return null;
+        return parsed.url === metroUrl() ? parsed.token : null;
+    }
+    catch {
+        return null;
+    }
+}
+export function writeRunToken(agentId, token) {
+    const path = tokenPath(agentId);
+    mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
+    writeFileSync(path, JSON.stringify({ token, url: metroUrl() }, null, 2));
+    chmodSync(path, 0o600);
+}
+const PROBE_TIMEOUT_MS = 15_000;
+export async function runTokenState(token) {
+    let res;
+    try {
+        res = await fetch(`${metroUrl()}/api/run/config`, {
+            headers: { authorization: `Bearer ${token}` },
+            signal: AbortSignal.timeout(PROBE_TIMEOUT_MS),
+            redirect: 'manual',
+        });
+    }
+    catch {
+        return 'unreachable';
+    }
+    await res.arrayBuffer().catch(() => undefined);
+    if (res.ok)
+        return 'ok';
+    return res.status === 401 || res.status === 403 || res.status === 409
+        ? 'stale'
+        : 'unreachable';
+}
+export const localPort = () => Number(process.env.METRO_WEBHOOK_PORT) || 8420;
+export const localUrl = () => `http://127.0.0.1:${String(localPort())}`;
+export function daemonPlan(opts) {
+    return {
+        command: findBun(),
+        args: [SERVER_ENTRY],
+        cwd: opts.dir,
+        env: {
+            ...process.env,
+            METRO_RUN_TOKEN: opts.token,
+            METRO_AGENT: opts.agentId,
+            METRO_URL: metroUrl(),
+            METRO_HTTP_HOST: process.env.METRO_HTTP_HOST ?? '127.0.0.1',
+            METRO_TRAINS_DIR: join(opts.dir, 'trains'),
+        },
+    };
+}
+export function runDaemon(agentId, plan) {
+    process.stderr.write(`Starting metro for ${agentId}\n`);
+    return spawnPlan(plan);
+}
+export function spawnPlan(plan) {
+    const child = spawn(plan.command, plan.args, {
+        cwd: plan.cwd,
+        env: plan.env,
+        stdio: ['ignore', 'inherit', 'inherit'],
+    });
+    const relay = (sig) => () => {
+        child.kill(sig);
+    };
+    process.on('SIGINT', relay('SIGINT'));
+    process.on('SIGTERM', relay('SIGTERM'));
+    return new Promise((resolve) => {
+        child.on('exit', (code) => {
+            resolve(code ?? 0);
+        });
+    });
+}

package/dist/serve.js

@@ -0,0 +1,77 @@
+import { spawnSync } from 'node:child_process';
+import { join } from 'node:path';
+import { serveLockedBy, serveStateDir } from './control.js';
+import { findBun, localPort, runtimeDir, SERVER_ENTRY, spawnPlan, } from './runtime.js';
+const SCRUBBED = new Set(['METRO_RUN_TOKEN', 'METRO_AGENT', 'DATABASE_URL']);
+const PORT_FLAG = /^--port=(.*)$/;
+const USAGE = 'usage: metro serve [--port <n>] [--tunnel]';
+function portOf(raw) {
+    const n = Number(raw);
+    if (raw === undefined || raw === '' || !Number.isInteger(n) || n < 1 || n > 65535)
+        throw new Error(`'${raw ?? ''}' is not a port — ${USAGE}`);
+    return n;
+}
+export function parseServeArgs(argv) {
+    let port = localPort();
+    let tunnel = false;
+    for (let i = 0; i < argv.length; i += 1) {
+        const arg = argv[i] ?? '';
+        if (arg === '--tunnel') {
+            tunnel = true;
+            continue;
+        }
+        const inline = PORT_FLAG.exec(arg);
+        if (inline) {
+            port = portOf(inline[1]);
+            continue;
+        }
+        if (arg === '--port' || arg === '-p') {
+            port = portOf(argv[i + 1]);
+            i += 1;
+            continue;
+        }
+        throw new Error(`unknown argument '${arg}' — ${USAGE}`);
+    }
+    return { port, tunnel };
+}
+export function findCloudflared() {
+    const found = spawnSync('cloudflared', ['--version'], { stdio: 'ignore' });
+    if (found.error !== undefined || found.status !== 0)
+        throw new Error('metro serve --tunnel needs cloudflared, which is not on PATH.\n' +
+            'Debian/Ubuntu (it is not in the distro repos; this adds Cloudflare\'s signed one):\n' +
+            '  sudo mkdir -p --mode=0755 /usr/share/keyrings\n' +
+            '  curl -fsSL https://pkg.cloudflare.com/cloudflare-main.gpg | sudo tee /usr/share/keyrings/cloudflare-main.gpg >/dev/null\n' +
+            "  echo 'deb [signed-by=/usr/share/keyrings/cloudflare-main.gpg] https://pkg.cloudflare.com/cloudflared any main' | sudo tee /etc/apt/sources.list.d/cloudflared.list\n" +
+            '  sudo apt-get update && sudo apt-get install cloudflared\n' +
+            'macOS:  brew install cloudflared\n' +
+            'Others: https://pkg.cloudflare.com/');
+}
+export function servePlan(opts) {
+    const env = Object.fromEntries(Object.entries(process.env).filter(([key]) => !SCRUBBED.has(key)));
+    return {
+        command: findBun(),
+        args: [SERVER_ENTRY],
+        cwd: opts.dir,
+        env: {
+            ...env,
+            METRO_MODE: 'local',
+            METRO_WEBHOOK_PORT: String(opts.port),
+            METRO_HTTP_HOST: process.env.METRO_HTTP_HOST ?? '127.0.0.1',
+            METRO_TRAINS_DIR: join(opts.dir, 'trains'),
+            METRO_STATE_DIR: process.env.METRO_STATE_DIR ?? serveStateDir(),
+            ...(opts.tunnel ? { METRO_TUNNEL: 'quick' } : {}),
+        },
+    };
+}
+export function serve(argv) {
+    const { port, tunnel } = parseServeArgs(argv);
+    const running = serveLockedBy();
+    if (running !== null)
+        throw new Error(`a metro serve daemon is already running on this machine (pid ${String(running)}). ` +
+            'Stop it first: metro stop');
+    if (tunnel)
+        findCloudflared();
+    const plan = servePlan({ dir: runtimeDir(), port, tunnel });
+    process.stderr.write(`Starting a metro daemon of your own on http://127.0.0.1:${String(port)}\n`);
+    return spawnPlan(plan);
+}

package/dist/store.js

@@ -0,0 +1,93 @@
+import { chmodSync, mkdirSync, readdirSync, readFileSync, rmSync, writeFileSync, } from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, join } from 'node:path';
+const DEFAULT_BASE = 'https://mcp.metro.box';
+const DEFAULT_WEB = 'https://metro.box';
+function fromEnv(name, fallback) {
+    const raw = process.env[name]?.trim();
+    return raw === undefined || raw === '' ? fallback : raw.replace(/\/+$/, '');
+}
+export function metroUrl() {
+    return fromEnv('METRO_URL', DEFAULT_BASE);
+}
+export function metroWebUrl() {
+    return fromEnv('METRO_UI_URL', DEFAULT_WEB);
+}
+function configDir() {
+    const xdg = process.env.XDG_CONFIG_HOME?.trim();
+    const base = xdg === undefined || xdg === '' ? join(homedir(), '.config') : xdg;
+    return join(base, 'metro');
+}
+export function credentialsPath() {
+    return join(configDir(), 'credentials.json');
+}
+function readStoredAt(path) {
+    let raw;
+    try {
+        raw = readFileSync(path, 'utf8');
+    }
+    catch {
+        return null;
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+    if (typeof parsed !== 'object' || parsed === null)
+        return null;
+    const { token, url } = parsed;
+    if (typeof token !== 'string' || token === '')
+        return null;
+    return { token, url: typeof url === 'string' ? url : DEFAULT_BASE };
+}
+const readStored = () => readStoredAt(credentialsPath());
+const RUN_TOKEN_FILE = /^runtime-[A-Za-z0-9_-]{11}\.json$/;
+export function readRunTokens() {
+    const fromEnv = process.env.METRO_RUN_TOKEN?.trim();
+    if (fromEnv !== undefined && fromEnv !== '')
+        return [fromEnv];
+    let names;
+    try {
+        names = readdirSync(configDir());
+    }
+    catch {
+        return [];
+    }
+    const out = [];
+    for (const name of names) {
+        if (!RUN_TOKEN_FILE.test(name))
+            continue;
+        const stored = readStoredAt(join(configDir(), name));
+        if (stored !== null && stored.url === metroUrl())
+            out.push(stored.token);
+    }
+    return out;
+}
+export function readToken() {
+    const fromEnv = process.env.METRO_TOKEN?.trim();
+    if (fromEnv !== undefined && fromEnv !== '')
+        return fromEnv;
+    const stored = readStored();
+    if (stored === null)
+        return null;
+    return stored.url === metroUrl() ? stored.token : null;
+}
+export function writeToken(token) {
+    const path = credentialsPath();
+    mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
+    writeFileSync(path, `${JSON.stringify({ token, url: metroUrl() })}\n`, {
+        mode: 0o600,
+    });
+    chmodSync(path, 0o600);
+}
+export function clearToken() {
+    try {
+        rmSync(credentialsPath());
+    }
+    catch {
+        return;
+    }
+}

package/dist/tail.js

@@ -0,0 +1,120 @@
+import { runConfigKey } from './api.js';
+import { assertAgentId, localUrl, readRunToken } from './runtime.js';
+const BACKOFF_MS = [1_000, 2_000, 5_000];
+const STALL_MS = 90_000;
+export const backoffAt = (attempt) => BACKOFF_MS[Math.min(attempt, BACKOFF_MS.length - 1)] ?? 5_000;
+export function sseDataLines(buffer, chunk) {
+    const lines = (buffer + chunk).split('\n');
+    const rest = lines.pop() ?? '';
+    const events = [];
+    for (const raw of lines) {
+        const line = raw.endsWith('\r') ? raw.slice(0, -1) : raw;
+        if (!line.startsWith('data:'))
+            continue;
+        const value = line.slice(5);
+        events.push(value.startsWith(' ') ? value.slice(1) : value);
+    }
+    return { rest, events };
+}
+function keySource(agentId) {
+    const fromEnv = process.env.METRO_AGENT_KEY?.trim();
+    if (fromEnv !== undefined && fromEnv !== '')
+        return { resolve: () => Promise.resolve(fromEnv), fixed: true };
+    return {
+        resolve: () => {
+            const token = readRunToken(agentId);
+            if (token === null)
+                throw new Error(`this machine is not authorized for ${agentId} — ` +
+                    `run 'metro start ${agentId}' once, or set METRO_AGENT_KEY`);
+            return runConfigKey(token);
+        },
+        fixed: false,
+    };
+}
+const armStall = (control) => setTimeout(() => {
+    control.abort();
+}, STALL_MS);
+async function connect(key, signal) {
+    try {
+        return await fetch(`${localUrl()}/api/tail`, {
+            headers: { authorization: `Bearer ${key}` },
+            signal,
+        });
+    }
+    catch {
+        return null;
+    }
+}
+async function pump(body, control, stall) {
+    const reader = body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = '';
+    try {
+        for (;;) {
+            const { done, value } = await reader.read();
+            if (done)
+                return 'ended';
+            clearTimeout(stall.timer);
+            stall.timer = armStall(control);
+            const out = sseDataLines(buffer, decoder.decode(value, { stream: true }));
+            buffer = out.rest;
+            for (const event of out.events)
+                process.stdout.write(`${event}\n`);
+        }
+    }
+    catch {
+        return 'ended';
+    }
+}
+async function streamOnce(key) {
+    const control = new AbortController();
+    const stall = { timer: armStall(control) };
+    try {
+        const res = await connect(key, control.signal);
+        if (res === null)
+            return 'unreachable';
+        if (res.status === 401)
+            return 'unauthorized';
+        if (!res.ok || res.body === null)
+            return 'unreachable';
+        return await pump(res.body, control, stall);
+    }
+    finally {
+        clearTimeout(stall.timer);
+    }
+}
+function note(state, message) {
+    if (state.last === message)
+        return;
+    state.last = message;
+    process.stderr.write(`metro: ${message}\n`);
+}
+const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+async function settle(end, source, key, agentId, state) {
+    if (end === 'unauthorized') {
+        if (source.fixed)
+            throw new Error('the key in METRO_AGENT_KEY was refused by the local daemon');
+        note(state, 'key refused — fetching the current one');
+        return source.resolve();
+    }
+    if (end === 'unreachable')
+        note(state, `no metro daemon on ${localUrl()} — run 'metro start ${agentId}'`);
+    else
+        note(state, 'stream ended — reconnecting');
+    return key;
+}
+export async function tailEvents(argv) {
+    const agentId = assertAgentId(argv[0]);
+    const source = keySource(agentId);
+    let key = await source.resolve();
+    const state = { last: '' };
+    let attempt = 0;
+    for (;;) {
+        const end = await streamOnce(key);
+        if (end === 'ended')
+            attempt = 0;
+        key = await settle(end, source, key, agentId, state);
+        await delay(backoffAt(attempt));
+        attempt += 1;
+    }
+}

package/dist/update.js

@@ -0,0 +1,33 @@
+import { spawnSync } from 'node:child_process';
+import { currentVersion, isNewer, PACKAGE_NAME, publishedVersion, } from './version.js';
+export function managerFor(location) {
+    return location.includes('/.bun/') ? 'bun' : 'npm';
+}
+export function installArgs(manager, version) {
+    const spec = `${PACKAGE_NAME}@${version}`;
+    return manager === 'bun'
+        ? ['add', '--global', spec]
+        : ['install', '--global', spec];
+}
+export async function update() {
+    const current = currentVersion();
+    const newest = await publishedVersion();
+    if (newest === '') {
+        process.stderr.write('npm published no version this CLI understands\n');
+        return 1;
+    }
+    if (!isNewer(newest, current)) {
+        process.stderr.write(`metro ${current} is the newest published version\n`);
+        return 0;
+    }
+    const manager = managerFor(import.meta.url);
+    const args = installArgs(manager, newest);
+    process.stderr.write(`Updating metro ${current} to ${newest} with ${manager}\n`);
+    const run = spawnSync(manager, args, { stdio: 'inherit' });
+    if (run.error !== undefined || run.status !== 0) {
+        process.stderr.write(`That did not work. Run it yourself:\n  ${manager} ${args.join(' ')}\n`);
+        return 1;
+    }
+    process.stderr.write(`metro is now ${newest}\n`);
+    return 0;
+}

package/dist/version.js

@@ -0,0 +1,97 @@
+import { readFileSync } from 'node:fs';
+export const PACKAGE_NAME = '@stage-labs/metro';
+const REGISTRY = 'https://registry.npmjs.org';
+const TIMEOUT_MS = 15_000;
+export function parseVersion(raw) {
+    const match = /^(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?$/.exec(raw.trim());
+    if (match === null)
+        return null;
+    const core = [match[1], match[2], match[3]].map((n) => Number(n));
+    const pre = match[4] === undefined
+        ? []
+        : match[4]
+            .split('.')
+            .map((part) => (/^\d+$/.test(part) ? Number(part) : part));
+    return { core, pre };
+}
+function comparePart(left, right) {
+    if (left === undefined)
+        return -1;
+    if (right === undefined)
+        return 1;
+    if (left === right)
+        return 0;
+    if (typeof left === 'number' && typeof right === 'number')
+        return left < right ? -1 : 1;
+    if (typeof left === 'number')
+        return -1;
+    if (typeof right === 'number')
+        return 1;
+    return left < right ? -1 : 1;
+}
+function comparePre(a, b) {
+    if (a.length === 0 && b.length === 0)
+        return 0;
+    if (a.length === 0)
+        return 1;
+    if (b.length === 0)
+        return -1;
+    for (let i = 0; i < Math.max(a.length, b.length); i += 1) {
+        const cmp = comparePart(a[i], b[i]);
+        if (cmp !== 0)
+            return cmp;
+    }
+    return 0;
+}
+export function compareVersions(a, b) {
+    const left = parseVersion(a);
+    const right = parseVersion(b);
+    if (left === null || right === null)
+        return 0;
+    for (let i = 0; i < 3; i += 1) {
+        const l = left.core[i] ?? 0;
+        const r = right.core[i] ?? 0;
+        if (l !== r)
+            return l < r ? -1 : 1;
+    }
+    return comparePre(left.pre, right.pre);
+}
+export function isNewer(candidate, current) {
+    return compareVersions(candidate, current) > 0;
+}
+export function currentVersion() {
+    const path = new URL('../package.json', import.meta.url);
+    const raw = JSON.parse(readFileSync(path, 'utf8'));
+    return typeof raw.version === 'string' ? raw.version : '0.0.0';
+}
+export function newestOf(tags) {
+    let best = '';
+    for (const value of Object.values(tags)) {
+        if (typeof value !== 'string' || parseVersion(value) === null)
+            continue;
+        if (best === '' || isNewer(value, best))
+            best = value;
+    }
+    return best;
+}
+export async function publishedVersion() {
+    let res;
+    try {
+        res = await fetch(`${REGISTRY}/${PACKAGE_NAME.replace('/', '%2F')}`, {
+            headers: { accept: 'application/json' },
+            signal: AbortSignal.timeout(TIMEOUT_MS),
+        });
+    }
+    catch {
+        throw new Error('could not reach the npm registry');
+    }
+    if (!res.ok)
+        throw new Error(`npm answered ${String(res.status)}`);
+    const body = await res.json();
+    if (typeof body !== 'object' || body === null)
+        throw new Error('npm returned an unexpected response');
+    const tags = body['dist-tags'];
+    if (typeof tags !== 'object' || tags === null)
+        throw new Error('npm returned no dist-tags');
+    return newestOf(tags);
+}