@lettercamp/cli 0.1.7 → 0.1.8

package/dist/domain.js

@@ -0,0 +1,190 @@
+import { saveBinding } from './account.js';
+import { choose, ask, confirm } from './prompts.js';
+import { delay, publishingToken, request, selectHostingSite, status, waitForDeployment } from './hosting.js';
+export function domainAddress(address) {
+    let url;
+    try {
+        url = new URL(address.includes('://') ? address : `https://${address}`);
+    }
+    catch {
+        throw new Error('Enter an address such as blog.example.com or example.com/blog.');
+    }
+    if (url.protocol !== 'https:' || url.username || url.password || url.port || url.search || url.hash
+        || /[?#@\\\s]/.test(address) || /:\d/.test(address.replace(/^https:\/\//, '')) || /(?:^|\/)\.{1,2}(?:\/|$)/.test(address))
+        throw new Error('Use an HTTPS hostname or subfolder without credentials, ports, a query, or fragment.');
+    const basePath = url.pathname.replace(/\/+$/, '');
+    return { kind: basePath ? 'subfolder' : 'hostname', hostname: url.hostname, basePath };
+}
+export async function domain(address) {
+    const parsed = address && address !== 'remove' ? domainAddress(address) : undefined;
+    const token = await publishingToken();
+    let { site, binding } = await selectHostingSite(token, false);
+    const route = `sites/${site.id}/domain`;
+    let document = await request(token, route);
+    const connection = () => document.subfolder || document.domain;
+    const label = () => document.subfolder ? `${document.subfolder.hostname}${document.subfolder.basePath}` : document.domain?.hostname;
+    const mutate = async (action) => {
+        document = await request(token, route, { action, kind: document.subfolder ? 'subfolder' : 'hostname', connectionId: connection()?.id });
+    };
+    let removingSubfolder = false;
+    if (address === 'remove') {
+        if (!connection()) {
+            console.log('No custom address is connected.');
+            return;
+        }
+        if (!await confirm(`Disconnect ${label()}?`))
+            return;
+        removingSubfolder = !!document.subfolder;
+        await mutate('remove');
+        await finishRemoval();
+        return;
+    }
+    if (parsed) {
+        if (connection()) {
+            const same = parsed.kind === 'subfolder' ? document.subfolder?.hostname === parsed.hostname && document.subfolder.basePath === parsed.basePath
+                : !document.subfolder && document.domain?.hostname === parsed.hostname;
+            if (!same)
+                throw new Error(`This site already uses ${label()}. Run lettercamp domain remove before connecting another address.`);
+        }
+        else {
+            document = await request(token, route, { action: 'add', ...parsed });
+            binding = { ...binding, provider: undefined };
+            await saveBinding(binding);
+        }
+    }
+    if (!connection()) {
+        const current = await status(token, site.id);
+        console.log(`Site address: ${current.site.url}\nConnect an address with lettercamp domain blog.example.com or lettercamp domain example.com/blog.`);
+        return;
+    }
+    if (connection()?.status === 'removing') {
+        removingSubfolder = !!document.subfolder;
+        await finishRemoval();
+        return;
+    }
+    if (connection()?.status === 'active') {
+        await mutate('refresh');
+        if (connection()?.error)
+            throw new Error(connection().error);
+    }
+    if (connection()?.status === 'active') {
+        await finishAddress();
+        console.log(`Connected: https://${label()}/`);
+        return;
+    }
+    if (document.subfolder?.status === 'verifying') {
+        const providers = ['vercel', 'cloudflare', 'nginx'];
+        const provider = binding.provider ?? providers[await choose(`Where is ${document.subfolder.hostname} hosted?`, ['Vercel', 'Cloudflare', 'nginx'])];
+        binding = { ...binding, provider };
+        await saveBinding(binding);
+        if (!document.proxy)
+            throw new Error('Proxy configuration is unavailable. Run lettercamp domain again.');
+        console.log(document.proxy[provider]);
+        console.error(provider === 'vercel' ? 'Merge these rewrites into your existing website’s vercel.json, before catch-all rules, and deploy that website.'
+            : provider === 'nginx' ? 'Add these locations to the existing HTTPS server block, then reload nginx. Keep proxy_pass URLs without a trailing slash.'
+                : `Deploy this Worker and add a Worker route for ${document.subfolder.hostname}${document.subfolder.basePath}* on your existing proxied domain.`);
+        console.error('Keep your website’s DNS and HTTPS settings. The proxy must preserve the subfolder path.');
+        await ask('Press Enter after applying the proxy configuration');
+    }
+    else if (document.domain) {
+        printDns();
+        console.error('Add these records at your DNS provider. Keep the CNAME unproxied (DNS only).');
+        await ask('Press Enter after adding the DNS records');
+    }
+    if (connection()?.error && document.subfolder?.status === 'building') {
+        console.error(connection().error);
+        if (!await confirm('Retry publishing this address?'))
+            return;
+    }
+    let records = JSON.stringify(document.domain?.records.map(record => [record.name, record.value]));
+    const deadline = Date.now() + 10 * 60_000;
+    let previous = '';
+    while (Date.now() < deadline) {
+        await mutate('refresh');
+        const nextRecords = JSON.stringify(document.domain?.records.map(record => [record.name, record.value]));
+        if (nextRecords !== records) {
+            printDns();
+            records = nextRecords;
+        }
+        const current = connection();
+        if (!current)
+            throw new Error('The address was removed. Run lettercamp domain again to check your site.');
+        const message = `${current.status}${current.error ? `: ${current.error}` : ''}`;
+        if (message !== previous) {
+            console.error(message);
+            previous = message;
+        }
+        if (current.status === 'active') {
+            await finishAddress();
+            console.log(`Live at https://${label()}/`);
+            return;
+        }
+        if (document.subfolder?.status === 'building') {
+            const publishing = await status(token, site.id);
+            if (publishing.pending) {
+                await waitForDeployment(token, site.id, publishing.pending);
+                document = await request(token, route);
+                if (connection()?.status === 'active') {
+                    console.log(`Live at https://${label()}/`);
+                    return;
+                }
+            }
+            else if (current.error)
+                throw new Error(`${current.error} Run lettercamp domain to retry.`);
+        }
+        await delay(15_000);
+    }
+    throw new Error('Setup is still pending. Run lettercamp domain to check again; your setup has been saved.');
+    async function finishAddress() {
+        const deadline = Date.now() + 10 * 60_000;
+        while (Date.now() < deadline) {
+            const publishing = await status(token, site.id);
+            if (publishing.pending) {
+                await waitForDeployment(token, site.id, publishing.pending);
+                continue;
+            }
+            if (!publishing.addressPending) {
+                if (publishing.activity?.status === 'failed' && publishing.activity.summary === 'Updated site domain') {
+                    console.error(publishing.activity.error || 'The address rebuild failed.');
+                    if (!await confirm('Retry publishing this address?'))
+                        throw new Error('The address is connected, but its rebuild did not finish. Run lettercamp domain to retry.');
+                    await request(token, `sites/${site.id}/status`, { action: 'retry' });
+                    continue;
+                }
+                return;
+            }
+            await delay(3000);
+        }
+        throw new Error('The address is connected and waiting to rebuild. Run lettercamp domain to check again.');
+    }
+    function printDns() {
+        if (!document.domain)
+            return;
+        console.log(`DNS records for ${document.domain.hostname}:\n\nTYPE\tNAME\tVALUE`);
+        console.log(`CNAME\t${document.domain.hostname}\t${document.cnameTarget}`);
+        for (const record of document.domain.records)
+            console.log(`${record.type}\t${record.name}\t${record.value}`);
+    }
+    async function finishRemoval() {
+        const deadline = Date.now() + 10 * 60_000;
+        while (Date.now() < deadline) {
+            const publishing = await status(token, site.id);
+            if (publishing.pending)
+                await waitForDeployment(token, site.id, publishing.pending);
+            document = await request(token, route);
+            if (!connection()) {
+                await finishAddress();
+                console.log(`Site address: ${publishing.site.defaultUrl}`);
+                binding = { ...binding, provider: undefined };
+                await saveBinding(binding);
+                if (removingSubfolder)
+                    console.log('You can now remove the proxy rules from your existing website.');
+                return;
+            }
+            if (connection()?.error)
+                throw new Error(`${connection().error} Run lettercamp domain remove to retry.`);
+            await delay(5000);
+        }
+        throw new Error('Disconnection is still pending. Run lettercamp domain to check again.');
+    }
+}

package/dist/hosting.js

@@ -0,0 +1,132 @@
+import path from 'node:path';
+import { randomUUID } from 'node:crypto';
+import { apiOrigin, apiRequest, credentials, responseJson, login, projectPath, getBinding, saveBinding } from './account.js';
+import { ask, choose } from './prompts.js';
+export const delay = (ms) => new Promise(resolve => setTimeout(resolve, ms));
+export class ApiError extends Error {
+    status;
+    constructor(message, status) {
+        super(message);
+        this.status = status;
+    }
+}
+export async function request(token, route, body) {
+    const response = await apiRequest(`/api/cli/${route}`, body === undefined ? {} : {
+        method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify(body),
+    }, token, 120_000);
+    if (!response.ok) {
+        const result = await response.json().catch(() => ({}));
+        throw new ApiError(result.message || result.error || `Lettercamp returned HTTP ${response.status}.`, response.status);
+    }
+    return responseJson(response);
+}
+export async function publishingToken() {
+    let saved;
+    try {
+        saved = await credentials();
+    }
+    catch { /* First use starts browser login below. */ }
+    if (saved) {
+        const response = await apiRequest('/api/cli/session', {}, saved.token);
+        if (response.ok) {
+            const session = await responseJson(response);
+            if (session.canPublish)
+                return saved.token;
+            console.error('Sign in once more to authorize publishing and domain management.');
+        }
+        else if (response.status !== 401)
+            await responseJson(response);
+    }
+    await login({ browser: true });
+    return (await credentials()).token;
+}
+export async function selectHostingSite(token, allowCreate) {
+    let binding = await getBinding();
+    if (binding?.creation) {
+        try {
+            const { site } = await request(token, 'sites', binding.creation);
+            binding = { ...binding, siteId: site.id, creation: undefined };
+            await saveBinding(binding);
+            return { site, binding };
+        }
+        catch (error) {
+            if (error instanceof ApiError && error.status === 400)
+                await clearCreation(binding);
+            throw error;
+        }
+    }
+    const { sites: all } = await request(token, 'sites');
+    const sites = all.filter(site => site.publishingTarget === 'cloud');
+    const existing = binding && sites.find(site => site.id === binding?.siteId);
+    if (existing && binding)
+        return { site: existing, binding };
+    if (binding)
+        console.error('The saved site is unavailable for cloud publishing. Choose another site for this folder.');
+    if (!allowCreate && !sites.length)
+        throw new Error('Run lettercamp deploy first to create a site.');
+    const choices = [...(allowCreate ? ['Create a new site'] : []), ...sites.map(site => `${site.name} (${site.slug}.lettercamp.site)`)];
+    const selected = choices.length === 1 && !allowCreate && !binding ? 0 : await choose('Choose a site for this folder', choices);
+    if (allowCreate && selected === 0) {
+        const { workspaces } = await request(token, 'workspaces');
+        if (!workspaces.length)
+            throw new Error('No accessible workspace was found for this account.');
+        const workspace = workspaces[workspaces.length === 1 ? 0 : await choose('Choose a workspace', workspaces.map(workspace => workspace.name))];
+        const folder = path.basename(await projectPath());
+        const suggested = folder.replace(/[^a-z0-9 ]/gi, ' ').replace(/\s+/g, ' ').trim().slice(0, 80) || 'My Blog';
+        const name = await ask('Site name', suggested);
+        const slug = await ask('Site address (the part before .lettercamp.site)', folder.toLowerCase().replace(/[^a-z0-9-]/g, '-').replace(/^-+|-+$/g, '') || 'my-blog');
+        const id = randomUUID();
+        binding = { origin: apiOrigin(), siteId: id, fresh: true, creation: { id, workspaceId: workspace.id, name, slug } };
+        await saveBinding(binding);
+        try {
+            const { site } = await request(token, 'sites', binding.creation);
+            binding = { ...binding, creation: undefined };
+            await saveBinding(binding);
+            console.error(`Created ${site.slug}.lettercamp.site.`);
+            return { site, binding };
+        }
+        catch (error) {
+            // Definitive validation failures created nothing. Preserve uncertain requests for retry.
+            if (error instanceof ApiError && error.status === 400)
+                await clearCreation(binding);
+            throw error;
+        }
+    }
+    const site = sites[selected - (allowCreate ? 1 : 0)];
+    binding = { origin: apiOrigin(), siteId: site.id };
+    await saveBinding(binding);
+    return { site, binding };
+}
+async function clearCreation(binding) {
+    // Keep other projects' bindings, but remove this unsuccessful selection.
+    const { readConfig, saveConfig } = await import('./account.js');
+    const bindings = await readConfig('sites.json') ?? {};
+    const key = await projectPath();
+    if (bindings[key]?.siteId === binding.siteId)
+        delete bindings[key];
+    await saveConfig('sites.json', bindings);
+}
+export const status = (token, siteId, deployment) => request(token, `sites/${siteId}/status${deployment ? `?deployment=${encodeURIComponent(deployment)}` : ''}`);
+export async function waitForDeployment(token, siteId, id, onProgress) {
+    const deadline = Date.now() + 46 * 60_000;
+    let previous = '';
+    while (Date.now() < deadline) {
+        const result = await status(token, siteId, id);
+        const activity = result.activity;
+        if (!activity)
+            throw new Error('Deployment not found. Run lettercamp deploy again to resume your upload.');
+        if (onProgress)
+            await onProgress(activity);
+        const progress = `${activity.status}:${activity.stage}`;
+        if (progress !== previous) {
+            console.error(`${activity.stage}…`);
+            previous = progress;
+        }
+        if (activity.status === 'succeeded')
+            return result;
+        if (activity.status === 'failed' || activity.status === 'cancelled')
+            throw new Error(activity.error || `Deployment ${activity.status}. Run lettercamp deploy to retry.`);
+        await delay(3000);
+    }
+    throw new Error('Publishing is still in progress. Run lettercamp deploy again to check it.');
+}

package/dist/lettercamp.js

@@ -1,11 +1,8 @@
 #!/usr/bin/env node
 import semver from 'semver';
 try {
-    if (!semver.satisfies(process.versions.node, '>=22.17.0')) {
-        throw new Error(`Node.js 22.17 or newer is required (you have ${process.versions.node}).`);
-    }
     if (!semver.satisfies(process.versions.node, '>=22.22.0')) {
-        console.warn(`Lettercamp: Continuing with Node.js ${process.versions.node}. Some dependencies require Node.js 22.22 or newer; upgrade if you encounter compatibility issues.`);
+        throw new Error(`Node.js 22.22 or newer is required (you have ${process.versions.node}).`);
     }
     const { run } = await import('./cli.js');
     await run();

package/dist/media-dimensions.js

@@ -0,0 +1,154 @@
+import { open, realpath } from 'node:fs/promises';
+import path from 'node:path';
+import { imageMetadata } from 'astro/assets/utils';
+import { fromHtml } from 'hast-util-from-html';
+import { toHtml } from 'hast-util-to-html';
+const positive = (value) => Number.isFinite(Number(value)) && Number(value) > 0 ? Number(value) : undefined;
+const maxProbeBytes = 1024 * 1024;
+// Derive dimensions in the build, so visitors receive reserved space in the HTML.
+// Probe only publication files and our asset origin; arbitrary external embeds
+// retain their authored dimensions and never cause new server-side requests.
+export function mediaDimensions(options) {
+    const cache = new Map();
+    async function probe(src, file) {
+        try {
+            if (/^(?:[a-z][\w+.-]*:|\/\/)/i.test(src)) {
+                const url = new URL(src);
+                if (url.origin !== 'https://assets.lettercamp.com' || url.username || url.password)
+                    return;
+                const response = await fetch(url, { redirect: 'error', signal: AbortSignal.timeout(5000) });
+                if (!response.body)
+                    return;
+                if (!response.ok) {
+                    await response.body.cancel();
+                    return;
+                }
+                const reader = response.body.getReader();
+                let bytes = new Uint8Array();
+                try {
+                    while (bytes.length < maxProbeBytes) {
+                        const { done, value } = await reader.read();
+                        if (done)
+                            break;
+                        const next = new Uint8Array(Math.min(maxProbeBytes, bytes.length + value.length));
+                        next.set(bytes);
+                        next.set(value.subarray(0, next.length - bytes.length), bytes.length);
+                        bytes = next;
+                        try {
+                            return await imageMetadata(bytes, src);
+                        }
+                        catch { /* Read until the header is complete. */ }
+                    }
+                }
+                finally {
+                    await reader.cancel().catch(() => undefined);
+                    reader.releaseLock();
+                }
+                return;
+            }
+            const pathname = decodeURIComponent(src.split(/[?#]/, 1)[0]);
+            const filename = await realpath(pathname.startsWith('/') ? path.resolve(options.root, '.' + pathname) : path.resolve(path.dirname(file.path ?? path.join(options.root, 'pages', 'index.md')), pathname));
+            const root = await realpath(options.root);
+            if (!filename.startsWith(root + path.sep))
+                return;
+            const handle = await open(filename, 'r');
+            try {
+                const bytes = Buffer.alloc(maxProbeBytes);
+                const { bytesRead } = await handle.read(bytes, 0, bytes.length, 0);
+                return await imageMetadata(bytes.subarray(0, bytesRead), src);
+            }
+            finally {
+                await handle.close();
+            }
+        }
+        catch {
+            return;
+        } // Unavailable images must not prevent publication.
+    }
+    function size(src, file) {
+        const key = /^(?:https?:|\/)/.test(src) ? src : `${file.path ?? ''}:${src}`;
+        let pending = cache.get(key);
+        if (!pending) {
+            pending = probe(src, file);
+            cache.set(key, pending);
+        }
+        return pending;
+    }
+    async function transform(tree, file) {
+        const jobs = [];
+        const definitions = new Map();
+        function findDefinitions(node) {
+            if (node.type === 'definition' && node.identifier && node.url)
+                definitions.set(node.identifier.toLowerCase(), node.url);
+            node.children?.forEach(findDefinitions);
+        }
+        findDefinitions(tree);
+        function visit(node) {
+            if (['html', 'raw'].includes(node.type) && node.value && /<img\b/i.test(node.value))
+                jobs.push(async () => {
+                    const fragment = fromHtml(node.value, { fragment: true });
+                    await transform(fragment, { path: file.path, data: {} });
+                    // Replace only image tags; parsing an isolated opening <div> must not
+                    // insert a closing tag ahead of the following Markdown block.
+                    const replacements = [];
+                    function collect(element) {
+                        if (element.type === 'element' && element.tagName === 'img' && element.position?.start.offset !== undefined && element.position.end.offset !== undefined) {
+                            replacements.push({ start: element.position.start.offset, end: element.position.end.offset, html: toHtml(element) });
+                        }
+                        if ('children' in element)
+                            element.children.forEach(collect);
+                    }
+                    collect(fragment);
+                    for (const replacement of replacements.sort((a, b) => b.start - a.start)) {
+                        node.value = node.value.slice(0, replacement.start) + replacement.html + node.value.slice(replacement.end);
+                    }
+                });
+            const jsx = ['mdxJsxFlowElement', 'mdxJsxTextElement'].includes(node.type) && node.name === 'img';
+            const markdown = node.type === 'image' || node.type === 'imageReference';
+            if (jsx || markdown || node.type === 'element' && node.tagName === 'img') {
+                const properties = jsx ? Object.fromEntries((node.attributes ?? []).filter(a => a.type === 'mdxJsxAttribute').map(a => [a.name, a.value]))
+                    : markdown ? node.data?.hProperties ?? {} : node.properties ?? {};
+                const src = markdown ? node.url ?? definitions.get(node.identifier?.toLowerCase() ?? '') : properties.src;
+                const width = positive(properties.width), height = positive(properties.height);
+                // Leave dynamic dimensions and explicit sizing under the author's control.
+                const dynamic = jsx && node.attributes?.some(a => a.type !== 'mdxJsxAttribute' || ['width', 'height'].includes(a.name ?? '') && typeof a.value !== 'string');
+                const customSize = properties.width != null && !width || properties.height != null && !height;
+                if (typeof src === 'string' && !(width && height) && !dynamic && !customSize)
+                    jobs.push(async () => {
+                        const dimensions = await size(src, file);
+                        if (!dimensions)
+                            return;
+                        const w = width ?? (height ? Math.round(height * dimensions.width / dimensions.height) : dimensions.width);
+                        const h = height ?? Math.max(1, Math.round(w * dimensions.height / dimensions.width));
+                        const attrs = { width: w, height: h, ...(!width && !height ? { 'data-media-sized': 'true' } : {}) };
+                        if (jsx) {
+                            node.attributes = (node.attributes ?? []).filter(a => !['width', 'height'].includes(a.name ?? ''));
+                            for (const [name, value] of Object.entries(attrs))
+                                node.attributes.push({ type: 'mdxJsxAttribute', name, value: String(value) });
+                        }
+                        else if (markdown)
+                            node.data = { ...node.data, hProperties: { ...properties, ...attrs } };
+                        else
+                            node.properties = { ...properties, ...attrs };
+                    });
+            }
+            node.children?.forEach(visit);
+        }
+        visit(tree);
+        const frontmatter = file.data.astro?.frontmatter;
+        const cover = frontmatter?.image ?? frontmatter?.ogImage;
+        if (frontmatter && typeof cover === 'string' && cover && !(positive(frontmatter.coverImageWidth) && positive(frontmatter.coverImageHeight)))
+            jobs.push(async () => {
+                const width = frontmatter.image ? positive(frontmatter.imageWidth) : undefined;
+                const height = frontmatter.image ? positive(frontmatter.imageHeight) : undefined;
+                const dimensions = width && height ? { width, height } : await size(cover, file);
+                if (dimensions) {
+                    frontmatter.coverImageWidth = dimensions.width;
+                    frontmatter.coverImageHeight = dimensions.height;
+                }
+            });
+        for (let i = 0; i < jobs.length; i += 4)
+            await Promise.all(jobs.slice(i, i + 4).map(job => job()));
+    }
+    return transform;
+}

package/dist/new.js

@@ -35,7 +35,7 @@ export async function createSite(directory) {
             });
         }
         console.log(`\nCreated your publication at ${destination}`);
-        console.log('Open that directory and run: lettercamp dev');
+        console.log('Open that directory and run lettercamp dev to preview, or lettercamp deploy to publish.');
     }
     finally {
         await rm(temporary, { recursive: true, force: true });

package/dist/preview.js

@@ -39,7 +39,7 @@ export async function preview(directory, options) {
         for (const url of server.resolvedUrls.network)
             console.log(`  Network: ${url}`);
         console.log(`\nPreviewing ${contentRoot}`);
-        console.log('Changes to pages, images, and settings.json reload automatically.');
+        console.log('Changes to pages, components, styles, and settings.json reload automatically.');
         console.log('Press Ctrl+C to stop.\n');
     }
     finally {

package/dist/prompts.js

@@ -0,0 +1,31 @@
+import { createInterface } from 'node:readline/promises';
+export async function ask(label, fallback) {
+    if (!process.stdin.isTTY || !process.stderr.isTTY)
+        throw new Error('This step needs a terminal. Run this command interactively once to finish setup.');
+    const readline = createInterface({ input: process.stdin, output: process.stderr });
+    const abort = new AbortController();
+    readline.on('SIGINT', () => abort.abort());
+    try {
+        const value = (await readline.question(`${label}${fallback ? ` (${fallback})` : ''}: `, { signal: abort.signal })).trim();
+        return value || fallback || '';
+    }
+    catch {
+        throw new Error('Cancelled.');
+    }
+    finally {
+        readline.close();
+    }
+}
+export async function confirm(label) {
+    return /^(y|yes)$/i.test(await ask(`${label} [y/N]`));
+}
+export async function choose(label, choices) {
+    console.error(`\n${label}`);
+    choices.forEach((choice, i) => console.error(`  ${i + 1}. ${choice}`));
+    for (;;) {
+        const value = await ask('Choose a number', '1');
+        if (/^\d+$/.test(value) && Number(value) >= 1 && Number(value) <= choices.length)
+            return Number(value) - 1;
+        console.error(`Choose a number from 1 to ${choices.length}.`);
+    }
+}

package/dist/publication-links.js

@@ -0,0 +1,23 @@
+// Root-relative links in Markdown and literal MDX attributes belong to the publication.
+// Absolute URLs and anchors retain their authored meaning.
+export function publicationLinks(options) {
+    const base = options.basePath.replace(/\/+$/, '');
+    const prefix = (value) => value.startsWith('/') && !value.startsWith('//') ? base + value : value;
+    return (tree) => {
+        if (!base)
+            return;
+        function visit(node) {
+            if (['link', 'image', 'definition'].includes(node.type) && node.url)
+                node.url = prefix(node.url);
+            if (node.type === 'mdxJsxFlowElement' || node.type === 'mdxJsxTextElement') {
+                for (const attribute of node.attributes ?? []) {
+                    if (attribute.type === 'mdxJsxAttribute' && ['href', 'src', 'poster'].includes(attribute.name ?? '') && typeof attribute.value === 'string')
+                        attribute.value = prefix(attribute.value);
+                }
+            }
+            for (const child of node.children ?? [])
+                visit(child);
+        }
+        visit(tree);
+    };
+}

package/dist/react.js

@@ -0,0 +1,15 @@
+import { createRequire } from 'node:module';
+import path from 'node:path';
+const require = createRequire(import.meta.url);
+export const reactIntegrationDirectory = path.dirname(require.resolve('@astrojs/react/package.json'));
+// Astro resolves renderer entrypoints from the temporary workspace. Locate the
+// CLI's integration even when npm puts it in a nested node_modules folder.
+// The integration deduplicates React against the workspace's CLI dependencies.
+export const reactViteConfig = {
+    resolve: {
+        alias: Object.keys(require('@astrojs/react/package.json').exports).map(entry => {
+            const id = '@astrojs/react' + (entry === '.' ? '' : entry.slice(1));
+            return { find: new RegExp(`^${id.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}$`), replacement: require.resolve(id) };
+        }),
+    },
+};

package/dist/upload.js

@@ -1,27 +1,57 @@
 import { open } from 'node:fs/promises';
 import path from 'node:path';
 import { apiRequest, credentials, responseJson, selectUploadSite } from './account.js';
-export async function upload(file, options) {
-    const saved = await credentials();
+async function uploadFile(file, slug, token) {
     const handle = await open(file, 'r');
     let bytes;
     try {
         const info = await handle.stat();
         if (!info.isFile() || !info.size)
-            throw new Error('Choose a nonempty image file.');
+            throw new Error('Choose a nonempty image or font file.');
         if (info.size > 10 * 1024 * 1024)
-            throw new Error('Images must be 10 MB or smaller.');
+            throw new Error('Files must be 10 MB or smaller.');
         bytes = await handle.readFile();
         if (bytes.byteLength > 10 * 1024 * 1024)
-            throw new Error('Images must be 10 MB or smaller.');
+            throw new Error('Files must be 10 MB or smaller.');
     }
     finally {
         await handle.close();
     }
-    const { site, remember } = await selectUploadSite(saved.token, options.site);
-    const result = await responseJson(await apiRequest(`/api/sites/${encodeURIComponent(site.slug)}/assets`, {
+    const font = /\.(ttf|otf|woff2?)$/i.test(file);
+    return responseJson(await apiRequest(`/api/sites/${encodeURIComponent(slug)}/assets${font ? "?type=font" : ""}`, {
         method: 'POST', headers: { 'Content-Type': 'application/octet-stream', 'X-File-Name': encodeURIComponent(path.basename(file)) }, body: new Uint8Array(bytes),
-    }, saved.token));
-    await remember().catch(() => console.error('Uploaded successfully, but the site selection could not be saved. Use --site on your next upload.'));
-    console.log(options.json ? JSON.stringify(result) : result.url);
+    }, token));
+}
+export async function upload(files, options) {
+    const saved = await credentials();
+    const { site, remember } = await selectUploadSite(saved.token, options.site);
+    const multiple = files.length > 1;
+    const results = [];
+    let remembered = false;
+    for (const file of files) {
+        let result;
+        try {
+            result = await uploadFile(file, site.slug, saved.token);
+        }
+        catch (error) {
+            if (!multiple)
+                throw error;
+            const message = error instanceof Error ? error.message : String(error);
+            results.push({ file, error: message });
+            console.error(`${file}: ${message}`);
+            process.exitCode = 1;
+            continue;
+        }
+        results.push({ file, ...result });
+        if (!remembered) {
+            remembered = true;
+            await remember().catch(() => console.error('Uploaded successfully, but the site selection could not be saved. Use --site on your next upload.'));
+        }
+        if (!options.json)
+            console.log(multiple ? `${file}\t${result.url}` : result.url);
+        else if (!multiple)
+            console.log(JSON.stringify(result));
+    }
+    if (options.json && multiple)
+        console.log(JSON.stringify(results));
 }