@lettercamp/cli 0.1.6 → 0.1.8

package/dist/dev.js

@@ -1,9 +1,19 @@
+import { codeBlocks } from "./code-highlight.js";
 import { rm } from 'node:fs/promises';
 import path from 'node:path';
 import { dev } from 'astro';
 import mdx from '@astrojs/mdx';
+import react from '@astrojs/react';
+import { unified } from '@astrojs/markdown-remark';
 import { prepareWorkspace } from './workspace.js';
+import { selectDefaultPort } from './ports.js';
+import { readingTime } from './reading-time.js';
+import { mediaDimensions } from './media-dimensions.js';
+import { reactIntegrationDirectory, reactViteConfig } from './react.js';
+import { writeCustomLayout } from './custom-layout.js';
 export async function startDev(directory, options) {
+    // Astro is bundled with Lettercamp; users update it through the Lettercamp CLI.
+    process.env.ASTRO_DISABLE_UPDATE_CHECK = 'true';
     const { workspace, contentRoot, modules } = await prepareWorkspace(directory);
     let server;
     let closeVite;
@@ -31,39 +41,66 @@ export async function startDev(directory, options) {
         });
     };
     try {
+        const port = (options.useDefaultPorts ?? options.port === 3000)
+            ? await selectDefaultPort(options.host)
+            : options.port;
         server = await dev({
             root: workspace,
+            logLevel: 'warn',
             configFile: false,
-            publicDir: path.join(contentRoot, 'public'),
+            publicDir: path.join(workspace, '.lettercamp-no-public'),
             output: 'static',
-            integrations: [mdx()],
+            integrations: [mdx(), react()],
+            markdown: { syntaxHighlight: false, processor: unified({ remarkPlugins: [readingTime, codeBlocks, [mediaDimensions, { root: contentRoot }]], rehypePlugins: [[mediaDimensions, { root: contentRoot }]] }) },
             devToolbar: { enabled: false },
-            server: { port: options.port, host: options.host, open: options.open },
+            server: { port, host: options.host, open: options.open },
             vite: {
+                ...reactViteConfig,
+                clearScreen: false,
+                logLevel: 'warn',
                 plugins: [{
                         name: 'lettercamp-content',
                         configureServer(vite) {
                             closeVite = () => vite.close();
+                            // Lettercamp has no Socket.IO endpoint. Stray polling clients should
+                            // receive a 404 without repeatedly triggering Astro's page warnings.
+                            vite.middlewares.use((request, response, next) => {
+                                const pathname = request.url?.split('?', 1)[0];
+                                if (pathname !== '/socket.io' && pathname !== '/socket.io/')
+                                    return next();
+                                response.statusCode = 404;
+                                response.setHeader('Cache-Control', 'no-store');
+                                response.setHeader('Content-Type', 'text/plain; charset=utf-8');
+                                response.end('Not found');
+                            });
                             // Imported files are watched automatically, but external folders
                             // must be registered for newly created pages to be discovered.
-                            vite.watcher.add([path.join(contentRoot, 'pages'), path.join(contentRoot, 'public'), path.join(contentRoot, 'site.json')]);
+                            const components = path.join(contentRoot, 'components');
+                            vite.watcher.add([path.join(contentRoot, 'pages'), path.join(contentRoot, 'settings.json'), components]);
+                            let updatingLayout = Promise.resolve();
+                            const updateLayout = (file) => {
+                                if (path.dirname(file) !== components || !/^(Header|Footer)\.(jsx|tsx)$/.test(path.basename(file)))
+                                    return;
+                                updatingLayout = updatingLayout.then(async () => {
+                                    await writeCustomLayout(workspace, contentRoot);
+                                    // Also clear an earlier duplicate-file error when the valid
+                                    // slot source did not change. Add/remove is a rare full reload.
+                                    vite.moduleGraph.invalidateAll();
+                                    vite.ws.send({ type: 'full-reload' });
+                                }).catch(error => {
+                                    vite.config.logger.error(error.message);
+                                    vite.ws.send({ type: 'error', err: { message: error.message, stack: '' } });
+                                });
+                            };
+                            vite.watcher.on('add', updateLayout).on('unlink', updateLayout);
                         },
                     }],
-                // Astro interprets frontmatter.layout as an import. The publication's
-                // home/post names are presentation hints handled by our outer page.
-                resolve: {
-                    alias: {
-                        home: path.join(workspace, 'src/layouts/Content.astro'),
-                        post: path.join(workspace, 'src/layouts/Content.astro'),
-                    },
-                },
-                server: { strictPort: true, fs: { allow: [workspace, contentRoot, modules] } },
+                server: { strictPort: false, fs: { allow: [workspace, contentRoot, modules, reactIntegrationDirectory] } },
             },
         });
         process.once('SIGINT', stop);
         process.once('SIGTERM', stop);
-        console.log(`\nPreviewing ${contentRoot}\nChanges to pages, images, and site.json reload automatically. Press Ctrl+C to stop.\n`);
-        return { stop: cleanup, server };
+        return { stop: cleanup, server, contentRoot };
     }
     catch (error) {
         await cleanup();

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,8 +1,8 @@
 #!/usr/bin/env node
 import semver from 'semver';
 try {
-    if (!semver.satisfies(process.versions.node, '>=22.19.0')) {
-        throw new Error(`Node.js 22.19 or newer is required (you have ${process.versions.node}).`);
+    if (!semver.satisfies(process.versions.node, '>=22.22.0')) {
+        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/ports.js

@@ -0,0 +1,31 @@
+import { createServer } from 'node:net';
+async function isAvailable(port, host) {
+    return new Promise((resolve, reject) => {
+        const probe = createServer();
+        probe.once('error', (error) => {
+            if (error.code === 'EADDRINUSE')
+                resolve(false);
+            // IPv6 may be disabled on the machine. The IPv4 check still applies.
+            else if (['::', '::1'].includes(host) && ['EAFNOSUPPORT', 'EADDRNOTAVAIL'].includes(error.code ?? ''))
+                resolve(true);
+            else
+                reject(error);
+        });
+        probe.once('listening', () => probe.close(() => resolve(true)));
+        probe.listen({ port, host, exclusive: true });
+    });
+}
+export async function selectDefaultPort(host = 'localhost') {
+    const hosts = new Set([host, '0.0.0.0', '::', '127.0.0.1', '::1']);
+    candidates: for (const port of [3000, 8888, 4000, 5000, 6000, 7000, 8000]) {
+        // Check both address families, including wildcard listeners that can coexist
+        // with localhost on some systems but make the preview URL ambiguous.
+        for (const address of hosts) {
+            if (!await isAvailable(port, address))
+                continue candidates;
+        }
+        return port;
+    }
+    // Vite scans sequentially from here and handles bind-time collisions too.
+    return 3001;
+}