@lettercamp/cli 0.1.5 → 0.1.7

package/README.md

@@ -1,3 +1,5 @@
 # Lettercamp CLI
 
-The Lettercamp CLI. See **[lettercamp](https://www.npmjs.com/package/lettercamp)** for more documentation.
+The core package for the [Lettercamp CLI](https://www.npmjs.com/package/lettercamp).
+
+See the **[Lettercamp CLI documentation](https://www.lettercamp.com/docs/cli)** for installation instructions, commands, options, and troubleshooting.

package/dist/account.js

@@ -0,0 +1,177 @@
+import { chmod, mkdir, readFile, realpath, rename, rm, writeFile, access } from 'node:fs/promises';
+import { homedir, hostname } from 'node:os';
+import { randomUUID } from 'node:crypto';
+import { spawn } from 'node:child_process';
+import path from 'node:path';
+const configRoot = () => process.env.LETTERCAMP_CONFIG_DIR || path.join(process.platform === 'win32' ? process.env.APPDATA || path.join(homedir(), 'AppData', 'Roaming') : process.env.XDG_CONFIG_HOME || path.join(homedir(), '.config'), 'lettercamp');
+export function apiOrigin() {
+    const url = new URL(process.env.LETTERCAMP_API_URL || 'https://www.lettercamp.com');
+    const local = ['localhost', '127.0.0.1', '[::1]'].includes(url.hostname);
+    if ((url.protocol !== 'https:' && !(local && url.protocol === 'http:')) || url.username || url.password || url.pathname !== '/' || url.search || url.hash) {
+        throw new Error('LETTERCAMP_API_URL must be an HTTPS origin (HTTP is allowed for localhost development).');
+    }
+    return url.origin;
+}
+async function readConfig(name) {
+    try {
+        return JSON.parse(await readFile(path.join(configRoot(), name), 'utf8'));
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return null;
+        throw new Error(`Unable to read Lettercamp ${name}. Check ${configRoot()}.`);
+    }
+}
+async function saveConfig(name, value) {
+    await mkdir(configRoot(), { recursive: true, mode: 0o700 });
+    if (process.platform !== 'win32')
+        await chmod(configRoot(), 0o700);
+    const temporary = path.join(configRoot(), `.${name}-${randomUUID()}`);
+    try {
+        await writeFile(temporary, JSON.stringify(value, null, 2) + '\n', { mode: 0o600, flag: 'wx' });
+        await rename(temporary, path.join(configRoot(), name));
+    }
+    finally {
+        await rm(temporary, { force: true });
+    }
+}
+export async function credentials() {
+    const saved = await readConfig('credentials.json');
+    if (!saved || saved.origin !== apiOrigin() || typeof saved.token !== 'string' || !/^lc_[a-f0-9]{64}$/.test(saved.token)) {
+        throw new Error('Run lettercamp login to sign in to this server.');
+    }
+    return saved;
+}
+export async function apiRequest(route, options = {}, token) {
+    const headers = new Headers(options.headers);
+    if (token)
+        headers.set('Authorization', `Bearer ${token}`);
+    try {
+        return await fetch(new URL(route, apiOrigin()), { ...options, headers, redirect: 'error', signal: AbortSignal.timeout(30_000) });
+    }
+    catch {
+        throw new Error('Unable to reach Lettercamp. Check your connection and try again.');
+    }
+}
+export async function responseJson(response) {
+    let result;
+    try {
+        result = await response.json();
+    }
+    catch {
+        throw new Error(`Lettercamp returned an unexpected response (HTTP ${response.status}).`);
+    }
+    if (!response.ok) {
+        if (response.status === 401)
+            throw new Error('Your CLI session expired or was revoked. Run lettercamp login again.');
+        const problem = result;
+        throw new Error(typeof problem?.message === 'string' ? problem.message : typeof problem?.error === 'string' ? problem.error : `Request failed (HTTP ${response.status}).`);
+    }
+    return result;
+}
+async function openBrowser(url) {
+    const [command, args] = process.platform === 'darwin' ? ['open', [url]]
+        : process.platform === 'win32' ? ['rundll32', ['url.dll,FileProtocolHandler', url]] : ['xdg-open', [url]];
+    await new Promise((resolve, reject) => {
+        const child = spawn(command, [...args], { stdio: 'ignore', shell: false });
+        child.once('error', reject);
+        child.once('exit', code => code === 0 ? resolve() : reject(new Error('Browser could not open.')));
+    });
+}
+export async function login(options) {
+    const previous = await readConfig('credentials.json');
+    const name = options.name || `Lettercamp CLI on ${hostname()}`.slice(0, 80);
+    const login = await responseJson(await apiRequest('/api/cli/login', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ name }) }));
+    const verification = new URL(login.verification_uri_complete);
+    if (verification.origin !== apiOrigin() || verification.pathname !== '/cli/login')
+        throw new Error('Lettercamp returned an unexpected login address.');
+    console.error(`Your code: ${login.user_code}\nOpen ${verification.href}\nConfirm the matching code in your browser. Waiting for approval…`);
+    if (options.browser)
+        await openBrowser(verification.href).catch(() => console.error('Open the link above in a browser to continue.'));
+    const deadline = Date.now() + Math.min(login.expires_in, 600) * 1000;
+    let interval = Math.max(5, login.interval) * 1000;
+    while (Date.now() < deadline) {
+        await new Promise(resolve => setTimeout(resolve, interval));
+        if (Date.now() >= deadline)
+            break;
+        const response = await apiRequest('/api/cli/token', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ device_code: login.device_code }) });
+        const body = await response.json();
+        if (body.error === 'authorization_pending')
+            continue;
+        if (body.error === 'slow_down') {
+            interval = Math.min(interval + 5000, 30000);
+            continue;
+        }
+        if (body.error === 'access_denied')
+            throw new Error('Login was denied in the browser.');
+        if (body.error === 'expired_token')
+            throw new Error('Login expired or was already completed. Run lettercamp login again.');
+        if (!response.ok || !body.access_token || !/^lc_[a-f0-9]{64}$/.test(body.access_token) || !body.expires_at || !body.user)
+            throw new Error(body.message || 'Unable to finish login. Run lettercamp login again.');
+        try {
+            await saveConfig('credentials.json', { origin: apiOrigin(), token: body.access_token, expiresAt: body.expires_at, user: body.user });
+        }
+        catch {
+            await apiRequest('/api/cli/session', { method: 'DELETE' }, body.access_token).catch(() => undefined);
+            throw new Error('Unable to save the CLI credential. Check your configuration directory permissions and run lettercamp login again.');
+        }
+        if (previous?.origin === apiOrigin() && /^lc_[a-f0-9]{64}$/.test(previous.token)) {
+            try {
+                const revoked = await apiRequest('/api/cli/session', { method: 'DELETE' }, previous.token);
+                if (!revoked.ok && revoked.status !== 401)
+                    throw new Error();
+            }
+            catch {
+                console.error('Previous session could not be revoked. You can revoke it from your account page.');
+            }
+        }
+        console.log(`Signed in as ${body.user.email}.`);
+        return;
+    }
+    throw new Error('Login timed out. Run lettercamp login again.');
+}
+export async function whoami(options) {
+    const saved = await credentials();
+    const user = await responseJson(await apiRequest('/api/cli/session', {}, saved.token));
+    console.log(options.json ? JSON.stringify(user) : `${user.name} <${user.email}>`);
+}
+export async function logout() {
+    const saved = await readConfig('credentials.json');
+    if (!saved) {
+        console.log('Already signed out.');
+        return;
+    }
+    if (saved.origin !== apiOrigin())
+        throw new Error(`This credential belongs to ${saved.origin}. Set LETTERCAMP_API_URL to that origin to sign out.`);
+    const response = await apiRequest('/api/cli/session', { method: 'DELETE' }, saved.token);
+    if (!response.ok && response.status !== 401)
+        await responseJson(response);
+    await rm(path.join(configRoot(), 'credentials.json'), { force: true });
+    console.log('Signed out.');
+}
+async function projectPath() {
+    const cwd = await realpath(process.cwd());
+    for (let directory = cwd;; directory = path.dirname(directory)) {
+        try {
+            await access(path.join(directory, 'settings.json'));
+            return directory;
+        }
+        catch { /* Walk up to the publication root. */ }
+        if (path.dirname(directory) === directory)
+            return cwd;
+    }
+}
+export async function selectUploadSite(token, requested) {
+    const { sites } = await responseJson(await apiRequest('/api/cli/sites', {}, token));
+    const project = await projectPath();
+    const bindings = await readConfig('sites.json') ?? {};
+    const binding = bindings[project];
+    const selected = requested || (binding?.origin === apiOrigin() ? binding.siteId : undefined);
+    const site = selected ? sites.find(item => item.id === selected || item.slug === selected) : sites.length === 1 ? sites[0] : undefined;
+    if (!site) {
+        if (!sites.length)
+            throw new Error('No accessible sites. Create a site in Lettercamp first.');
+        throw new Error(`${selected ? 'That site is unavailable to this account.' : 'Choose a site for this publication.'} Use --site <slug>. Available sites: ${sites.map(item => item.slug).join(', ')}`);
+    }
+    return { site, remember: () => saveConfig('sites.json', { ...bindings, [project]: { origin: apiOrigin(), siteId: site.id } }) };
+}

package/dist/build.js

@@ -1,7 +1,9 @@
 import path from 'node:path';
 import { build } from 'astro';
 import mdx from '@astrojs/mdx';
+import { unified } from '@astrojs/markdown-remark';
 import { prepareWorkspace } from './workspace.js';
+import { readingTime } from './reading-time.js';
 export async function buildSite(directory, options) {
     const origin = new URL(options.site);
     if (!['https:', 'http:'].includes(origin.protocol))
@@ -12,7 +14,7 @@ export async function buildSite(directory, options) {
     if (outDir === root || root.startsWith(outDir + path.sep) || ['pages', 'public'].some(name => overlaps(outDir, path.join(root, name)))) {
         throw new Error('Output must not replace the publication or its source files.');
     }
-    const { workspace, contentRoot, cleanup } = await prepareWorkspace(root);
+    const { workspace, cleanup } = await prepareWorkspace(root);
     const previousCwd = process.cwd();
     try {
         // Astro 7 places temporary prerender modules relative to cwd when outDir
@@ -21,13 +23,10 @@ export async function buildSite(directory, options) {
         await build({
             root: workspace, configFile: false, site: origin.origin,
             cacheDir: path.join(workspace, '.cache'),
-            publicDir: path.join(contentRoot, 'public'), outDir, output: 'static',
+            publicDir: path.join(workspace, 'public'), outDir, output: 'static',
             integrations: [mdx()],
+            markdown: { processor: unified({ remarkPlugins: [readingTime] }) },
             build: { format: 'directory', ...(options.assetsPrefix ? { assetsPrefix: options.assetsPrefix } : {}) },
-            vite: { resolve: { alias: {
-                        home: path.join(workspace, 'src/layouts/Content.astro'),
-                        post: path.join(workspace, 'src/layouts/Content.astro'),
-                    } } },
         });
         return outDir;
     }

package/dist/cli.js

@@ -1,10 +1,29 @@
 import { Command, InvalidArgumentError } from 'commander';
 import { version, showVersion, update } from './version.js';
+import { preview } from './preview.js';
 export async function run(argv = process.argv) {
     const program = new Command()
         .name('lettercamp')
         .description('Create and preview your Lettercamp publication.')
         .version(version, '-v, --version', 'Show the installed CLI version');
+    program.command('login')
+        .description('Sign in through your browser to upload images')
+        .option('--no-browser', 'Print the approval link without opening a browser')
+        .option('--name <name>', 'Name for this CLI session')
+        .action(async (options) => { const { login } = await import('./account.js'); await login(options); });
+    program.command('whoami')
+        .description('Show the signed-in account')
+        .option('--json', 'Print account details as JSON')
+        .action(async (options) => { const { whoami } = await import('./account.js'); await whoami(options); });
+    program.command('logout')
+        .description('Revoke this CLI session and remove its local credential')
+        .action(async () => { const { logout } = await import('./account.js'); await logout(); });
+    program.command('upload')
+        .description('Upload an image and print its permanent URL')
+        .argument('<file>', 'JPEG, PNG, WebP, or GIF image, up to 10 MB')
+        .option('--site <slug>', 'Destination site (remembered for this local publication)')
+        .option('--json', 'Print the URL and dimensions as JSON')
+        .action(async (file, options) => { const { upload } = await import('./upload.js'); await upload(file, options); });
     program.command('new')
         .description('Download the starter into a new or empty directory')
         .argument('[directory]', 'Destination directory', 'my-lettercamp')
@@ -20,7 +39,7 @@ export async function run(argv = process.argv) {
         .action(update);
     program.command('dev')
         .description('Preview the current publication with live reload')
-        .option('-p, --port <number>', 'Local port', (value) => {
+        .option('-p, --port <number>', 'Preferred local port (tries the next available port if busy)', (value) => {
         if (!/^\d+$/.test(value) || Number(value) < 1 || Number(value) > 65535) {
             throw new InvalidArgumentError('Use a port between 1 and 65535.');
         }
@@ -28,9 +47,11 @@ export async function run(argv = process.argv) {
     }, 3000)
         .option('--host <address>', 'Host to listen on', 'localhost')
         .option('--open', 'Open the preview in your browser', false)
-        .action(async (options) => {
-        const { startDev } = await import('./dev.js');
-        await startDev(process.cwd(), options);
+        .action(async (options, command) => {
+        await preview(process.cwd(), {
+            ...options,
+            useDefaultPorts: command.getOptionValueSource('port') === 'default',
+        });
     });
     program.command('build')
         .description('Build a static publication for hosting')

package/dist/dev.js

@@ -2,8 +2,14 @@ import { rm } from 'node:fs/promises';
 import path from 'node:path';
 import { dev } from 'astro';
 import mdx from '@astrojs/mdx';
+import { unified } from '@astrojs/markdown-remark';
 import { prepareWorkspace } from './workspace.js';
+import { selectDefaultPort } from './ports.js';
+import { readingTime } from './reading-time.js';
+import { updatePublicAsset } from './public-assets.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 +37,53 @@ 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, 'public'),
             output: 'static',
             integrations: [mdx()],
+            markdown: { processor: unified({ remarkPlugins: [readingTime] }) },
             devToolbar: { enabled: false },
-            server: { port: options.port, host: options.host, open: options.open },
+            server: { port, host: options.host, open: options.open },
             vite: {
+                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')]);
+                            vite.watcher.add([path.join(contentRoot, 'pages'), path.join(contentRoot, 'public'), path.join(contentRoot, 'settings.json')]);
+                            vite.watcher.on('all', (event, file) => {
+                                void updatePublicAsset(contentRoot, workspace, file, event).catch(error => {
+                                    vite.config.logger.error(`Unable to update public file: ${error.message}`);
+                                });
+                            });
                         },
                     }],
-                // 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] } },
             },
         });
         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/lettercamp.js

@@ -1,8 +1,11 @@
 #!/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.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.`);
     }
     const { run } = await import('./cli.js');
     await run();

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;
+}

package/dist/preview.js

@@ -0,0 +1,48 @@
+import { clearLine, cursorTo } from 'node:readline';
+export async function preview(directory, options) {
+    console.log('\nWelcome to the Lettercamp CLI!\n');
+    const output = process.stdout;
+    const frames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+    let frame = 0;
+    const render = () => {
+        cursorTo(output, 0);
+        output.write(`${frames[frame++ % frames.length]} Starting your preview…`);
+    };
+    let timer;
+    if (output.isTTY && process.env.TERM !== 'dumb') {
+        render();
+        timer = setInterval(render, 80);
+        timer.unref();
+    }
+    else {
+        console.log('Starting your preview…');
+    }
+    const finishLoading = () => {
+        if (!timer)
+            return;
+        clearInterval(timer);
+        timer = undefined;
+        cursorTo(output, 0);
+        clearLine(output, 0);
+    };
+    try {
+        // Keep the welcome and animation ahead of the renderer's slower imports.
+        const { startDev } = await import('./dev.js');
+        const { server, contentRoot } = await startDev(directory, options);
+        finishLoading();
+        if (server.address.port !== options.port) {
+            console.log(`Port ${options.port} is in use. Using port ${server.address.port} instead.\n`);
+        }
+        console.log('Your publication is ready.\n');
+        for (const url of server.resolvedUrls.local)
+            console.log(`  Local:   ${url}`);
+        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('Press Ctrl+C to stop.\n');
+    }
+    finally {
+        finishLoading();
+    }
+}

package/dist/public-assets.js

@@ -0,0 +1,29 @@
+import { cp, mkdir, rm } from 'node:fs/promises';
+import path from 'node:path';
+// Publication images live at remote URLs. Keep other public files (robots.txt,
+// downloads, etc.) available without copying images into each deployment.
+const imageFile = /\.(?:avif|bmp|gif|heic|heif|ico|jpe?g|png|svg|tiff?|webp)$/i;
+export async function copyPublicAssets(contentRoot, workspace) {
+    await mkdir(path.join(workspace, 'public'), { recursive: true });
+    try {
+        await cp(path.join(contentRoot, 'public'), path.join(workspace, 'public'), {
+            recursive: true, filter: source => !imageFile.test(source),
+        });
+    }
+    catch (error) {
+        if (error.code !== 'ENOENT')
+            throw error;
+    }
+}
+export async function updatePublicAsset(contentRoot, workspace, file, event) {
+    const relative = path.relative(path.join(contentRoot, 'public'), file);
+    if (!relative || relative.startsWith('..') || path.isAbsolute(relative) || imageFile.test(relative))
+        return;
+    const destination = path.join(workspace, 'public', relative);
+    if (event === 'unlink' || event === 'unlinkDir')
+        await rm(destination, { recursive: true, force: true });
+    else if (event === 'add' || event === 'change') {
+        await mkdir(path.dirname(destination), { recursive: true });
+        await cp(file, destination);
+    }
+}

package/dist/reading-time.js

@@ -0,0 +1,25 @@
+// Runs on parsed Markdown/MDX, so frontmatter, imports, URLs, and JSX
+// attributes never count as prose. Runtime-generated component text is unknown.
+export function readingTime() {
+    return (tree, file) => {
+        const text = [];
+        function visit(node) {
+            if (node.type === 'text' || node.type === 'inlineCode')
+                text.push(node.value ?? '');
+            for (const child of node.children ?? [])
+                visit(child);
+        }
+        visit(tree);
+        const segmenter = new Intl.Segmenter(undefined, { granularity: 'word' });
+        let words = 0;
+        for (const segment of segmenter.segment(text.join(' '))) {
+            if (segment.isWordLike)
+                words++;
+        }
+        const astro = file.data.astro;
+        if (astro?.frontmatter) {
+            // Always overwrite frontmatter: this is derived content, not an override.
+            astro.frontmatter.readingMinutes = Math.max(1, Math.ceil(words / 200));
+        }
+    };
+}

package/dist/upload.js

@@ -0,0 +1,27 @@
+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();
+    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.');
+        if (info.size > 10 * 1024 * 1024)
+            throw new Error('Images 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.');
+    }
+    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`, {
+        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);
+}

package/dist/workspace.js

@@ -4,16 +4,18 @@ import { tmpdir } from 'node:os';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { escapePath } from 'tinyglobby';
+import { copyPublicAssets } from './public-assets.js';
 const require = createRequire(import.meta.url);
 const renderer = fileURLToPath(new URL('../renderer/', import.meta.url));
 export async function prepareWorkspace(directory) {
     const contentRoot = await realpath(directory);
-    JSON.parse(await readFile(path.join(contentRoot, 'site.json'), 'utf8'));
+    JSON.parse(await readFile(path.join(contentRoot, 'settings.json'), 'utf8'));
     if (!(await stat(path.join(contentRoot, 'pages'))).isDirectory())
         throw new Error('Missing pages directory.');
     const workspace = await realpath(await mkdtemp(path.join(tmpdir(), 'lettercamp-')));
     try {
         await cp(renderer, workspace, { recursive: true });
+        await copyPublicAssets(contentRoot, workspace);
         await writeFile(path.join(workspace, 'package.json'), JSON.stringify({ private: true, type: 'module' }));
         // Dependencies stay in the CLI installation; the glob uses real source paths
         // so Vite sees additions and deletions without a symlink/realpath mismatch.
@@ -21,8 +23,9 @@ export async function prepareWorkspace(directory) {
         await symlink(modules, path.join(workspace, 'node_modules'), 'junction');
         const contentPrefix = path.relative(path.join(workspace, 'src'), path.join(contentRoot, 'pages')).replaceAll('\\', '/') + '/';
         await writeFile(path.join(workspace, 'src', 'content.js'), `export const contentPrefix = ${JSON.stringify(contentPrefix)};\n` +
-            `export const pages = import.meta.glob(${JSON.stringify(escapePath(contentPrefix) + '**/*.{md,mdx}')}, { eager: true });\n`);
-        await writeFile(path.join(workspace, 'src', 'site.js'), `export { default } from ${JSON.stringify(path.join(contentRoot, 'site.json').replaceAll('\\', '/'))};\n`);
+            `const allPages = import.meta.glob(${JSON.stringify(escapePath(contentPrefix) + '*.{md,mdx}')}, { eager: true });\n` +
+            `export const pages = Object.fromEntries(Object.entries(allPages).filter(([filename, page]) => !/\\/index\\.mdx?$/.test(filename) && page.frontmatter?.draft !== true));\n`);
+        await writeFile(path.join(workspace, 'src', 'site.js'), `export { default } from ${JSON.stringify(path.join(contentRoot, 'settings.json').replaceAll('\\', '/'))};\n`);
         return { workspace, contentRoot, modules, cleanup: () => rm(workspace, { recursive: true, force: true, maxRetries: 3 }) };
     }
     catch (error) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lettercamp/cli",
-  "version": "0.1.5",
+  "version": "0.1.7",
   "description": "The repository for the Lettercamp CLI",
   "keywords": [
     "lettercamp",
@@ -26,7 +26,7 @@
     "renderer"
   ],
   "engines": {
-    "node": ">=22.19.0"
+    "node": ">=22.17.0"
   },
   "scripts": {
     "build": "tsc",
@@ -38,6 +38,7 @@
     "registry": "https://registry.npmjs.org/"
   },
   "dependencies": {
+    "@astrojs/markdown-remark": "^7.3.3",
     "@astrojs/mdx": "8.0.3",
     "astro": "7.3.8",
     "commander": "^15.0.0",

package/renderer/src/components/AuthorByline.astro

@@ -0,0 +1,17 @@
+---
+const { post, site, variant = 'article' } = Astro.props;
+const author = post.author ?? site.author;
+const authorImage = post.authorImage ?? (author === site.author ? site.authorImage : undefined);
+const showReadingTime = variant === 'article' && site.showReadingTime !== false && typeof post.readingMinutes === 'number';
+const showDate = variant === 'listing' && post.date?.label;
+---
+
+{(author || showReadingTime || showDate) && <div class="post-byline">
+  {author && <span class="post-author">
+    {authorImage && <img class="author-avatar" src={authorImage} width="24" height="24" alt="" loading="lazy" />}
+    <span>{author}</span>
+  </span>}
+  {author && showDate && <span class="byline-separator" aria-hidden="true">·</span>}
+  {showDate && <time datetime={post.date.iso}>{post.date.label}</time>}
+  {showReadingTime && <span class="reading-time">{post.readingMinutes} min read</span>}
+</div>}