runcloud 0.1.2

package/dist/commands/deploy.js

@@ -0,0 +1,155 @@
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { ApiClient, ApiError, friendlyApiError } from '../api.js';
+import { requireCredentials, resolveProject } from '../config.js';
+import { createSnapshot } from '../archive.js';
+import { parseSseFrames } from '../sse.js';
+import { assertKnownServices, parseServiceFilter, readBackendServices } from '../services-manifest.js';
+const POLL_INTERVAL_MS = 5_000;
+const POLL_TIMEOUT_MS = 20 * 60 * 1000;
+export async function pollRun(client, runId, opts = {}) {
+    const intervalMs = opts.intervalMs ?? POLL_INTERVAL_MS;
+    const timeoutMs = opts.timeoutMs ?? POLL_TIMEOUT_MS;
+    const deadline = Date.now() + timeoutMs;
+    for (;;) {
+        const run = await client.get(`/newly_backend/deploy_runs/${runId}`);
+        if (run.status !== 'running')
+            return run;
+        if (Date.now() > deadline)
+            throw new Error(`Deploy run ${runId} timed out after ${timeoutMs / 1000}s`);
+        await new Promise((r) => setTimeout(r, intervalMs));
+    }
+}
+export async function streamRun(client, runId, print = (s) => process.stdout.write(s)) {
+    let buffer = '';
+    let started = false;
+    try {
+        for await (const chunk of client.stream(`/newly_backend/deploy_runs/${runId}/logs/stream`)) {
+            started = true;
+            buffer = (buffer + chunk).replace(/\r\n/g, '\n');
+            const lastSep = buffer.lastIndexOf('\n\n');
+            if (lastSep === -1)
+                continue;
+            const ready = buffer.slice(0, lastSep + 2);
+            buffer = buffer.slice(lastSep + 2);
+            for (const frame of parseSseFrames(ready)) {
+                if (frame.event === 'done') {
+                    return JSON.parse(frame.data);
+                }
+                try {
+                    print(JSON.parse(frame.data));
+                }
+                catch {
+                    print(frame.data);
+                }
+            }
+        }
+    }
+    catch (e) {
+        if (e instanceof ApiError && e.status === 404) {
+            return pollRun(client, runId);
+        }
+        if (started) {
+            return pollRun(client, runId);
+        }
+        throw e;
+    }
+    return pollRun(client, runId);
+}
+export function finishOrThrow(run, label) {
+    if (run.status === 'succeeded') {
+        console.log(`${label} deploy succeeded.`);
+        return;
+    }
+    if (run.failure_reason === 'no_backend_code') {
+        throw new Error('No backend code to deploy (backend/ missing).');
+    }
+    throw new Error(`${label} deploy failed (${run.failure_reason ?? 'unknown'}):\n${run.output_tail ?? ''}`);
+}
+export async function runDevDeploy(projectId, client, dir, services = []) {
+    if (!existsSync(join(dir, 'backend'))) {
+        throw new Error('No backend/ in this directory. Run `newly pull <project-id>` first, ' +
+            'or cd into a pulled project.');
+    }
+    console.log('Packaging local backend…');
+    const snapshot = await createSnapshot(dir);
+    const kib = snapshot.length < 1024 ? '<1' : Math.round(snapshot.length / 1024).toString();
+    console.log(`Uploading snapshot (${kib} KiB) and deploying server-side…`);
+    const params = new URLSearchParams({ env: 'dev' });
+    for (const service of services)
+        params.append('services', service);
+    const { run_id } = await client.upload(`/newly_backend/deploy/${projectId}?${params}`, snapshot, 'application/gzip');
+    const run = await streamRun(client, run_id);
+    finishOrThrow(run, 'dev');
+}
+export async function runProdDeploy(projectId, client, gitSha = 'HEAD', services = []) {
+    const label = gitSha === 'HEAD' ? 'repo HEAD' : gitSha;
+    console.log(`Deploying prod from the canonical project code (${label})…`);
+    const { run_id } = await client.post(`/newly_backend/deploy/${projectId}`, {
+        env: 'prod',
+        git_sha: gitSha,
+        services,
+    });
+    const run = await streamRun(client, run_id);
+    finishOrThrow(run, 'prod');
+}
+export async function ensureBackendProvisioned(client, projectId, env, opts = {}) {
+    const print = opts.print ?? console.log;
+    const status = await client.get(`/newly_backend/status/${projectId}`);
+    if (status[env])
+        return;
+    print(`Provisioning ${env} backend…`);
+    if (env === 'dev') {
+        await client.post(`/newly_backend/provision_dev/${projectId}`, {
+            dev_region: opts.region ?? 'auto',
+        });
+    }
+    else {
+        await client.post(`/newly_backend/provision_prod/${projectId}`);
+    }
+    print(`Provisioned ${env} backend.`);
+}
+export function registerDeploy(program) {
+    program
+        .command('deploy')
+        .description('Provision if needed, then deploy the backend server-side')
+        .option('--env <env>', 'dev or prod', 'dev')
+        .option('--region <region>', "Newly server region hint for first-time dev provisioning (defaults to 'auto')", 'auto')
+        .option('--project <id>', 'project id (defaults to the linked directory)')
+        .option('--service <names>', 'comma-separated service names from backend/newly.services.json')
+        .option('--git-sha <sha>', 'prod git revision to deploy from canonical project code', 'HEAD')
+        .option('--yes', 'skip the prod confirmation prompt', false)
+        .action(async (opts) => {
+        try {
+            if (opts.env !== 'dev' && opts.env !== 'prod')
+                throw new Error('--env must be dev or prod');
+            const creds = requireCredentials();
+            const projectId = resolveProject(process.cwd(), opts.project);
+            const client = new ApiClient(creds.apiUrl, creds.token);
+            const services = parseServiceFilter(opts.service);
+            assertKnownServices(readBackendServices(process.cwd()), services);
+            const stackInfo = await client.get(`/newly_backend/stack/${projectId}`);
+            if (!stackInfo.cli_deployable) {
+                throw new Error('This project does not support CLI deploys yet. Use the Newly web app to deploy it.');
+            }
+            if (opts.env === 'dev' && !existsSync(join(process.cwd(), 'backend'))) {
+                throw new Error('No backend/ in this directory. Run `newly pull <project-id>` first, ' +
+                    'or cd into a pulled project.');
+            }
+            await ensureBackendProvisioned(client, projectId, opts.env, {
+                region: opts.region,
+                print: console.log,
+            });
+            if (opts.env === 'prod') {
+                await runProdDeploy(projectId, client, opts.gitSha, services);
+            }
+            else {
+                await runDevDeploy(projectId, client, process.cwd(), services);
+            }
+        }
+        catch (e) {
+            console.error(e instanceof ApiError ? friendlyApiError(e) : String(e instanceof Error ? e.message : e));
+            process.exitCode = 1;
+        }
+    });
+}

package/dist/commands/dns.js

@@ -0,0 +1,185 @@
+import { stdin as input, stdout as output } from 'node:process';
+import { createInterface } from 'node:readline/promises';
+import { ApiClient, friendlyApiError } from '../api.js';
+import { requireCredentials, resolveProject } from '../config.js';
+function makeClient(project) {
+    const creds = requireCredentials();
+    return {
+        client: new ApiClient(creds.apiUrl, creds.token),
+        projectId: resolveProject(process.cwd(), project),
+    };
+}
+export async function resolveDomain(client, projectId, domainNameOrId) {
+    const result = (await client.get(`/projects/${projectId}/domains`));
+    const domains = result.domains ?? [];
+    const domain = domains.find((item) => item.id === domainNameOrId ||
+        item.hostname === domainNameOrId ||
+        item.root_domain === domainNameOrId);
+    if (!domain)
+        throw new Error(`Domain ${domainNameOrId} is not connected to this project.`);
+    return domain;
+}
+export function renderRecord(record) {
+    const ttl = record.ttl === undefined ? '' : `  ttl=${record.ttl}`;
+    const proxied = record.proxied === undefined ? '' : `  proxied=${record.proxied}`;
+    const priority = record.priority === undefined ? '' : `  priority=${record.priority}`;
+    return `${record.id}  ${record.type}  ${record.name}  ${record.content}${ttl}${proxied}${priority}`;
+}
+async function confirm(prompt) {
+    const rl = createInterface({ input, output });
+    try {
+        const answer = (await rl.question(`${prompt} Type "yes" to continue: `)).trim().toLowerCase();
+        return answer === 'yes';
+    }
+    finally {
+        rl.close();
+    }
+}
+export function numberOrUndefined(value, optionName = 'number') {
+    if (value === undefined)
+        return undefined;
+    const trimmed = value.trim();
+    const parsed = Number(trimmed);
+    if (!trimmed) {
+        throw new Error(`${optionName} must be a finite number.`);
+    }
+    if (!Number.isFinite(parsed)) {
+        throw new Error(`${optionName} must be a finite number.`);
+    }
+    return parsed;
+}
+export async function runDnsList(client, projectId, domainName, log = console.log) {
+    const domain = await resolveDomain(client, projectId, domainName);
+    const result = (await client.get(`/projects/${projectId}/domains/${domain.id}/dns-records`));
+    if (!result.editable) {
+        log(JSON.stringify(result.instructions, null, 2));
+        return;
+    }
+    const records = result.records ?? [];
+    log(records.length ? records.map(renderRecord).join('\n') : 'No DNS records.');
+}
+export async function runDnsAdd(client, projectId, domainName, opts, log = console.log) {
+    const ttl = numberOrUndefined(opts.ttl, 'ttl');
+    const priority = numberOrUndefined(opts.priority, 'priority');
+    const domain = await resolveDomain(client, projectId, domainName);
+    const result = await client.post(`/projects/${projectId}/domains/${domain.id}/dns-records`, {
+        type: opts.type,
+        name: opts.name,
+        content: opts.content,
+        ttl,
+        proxied: opts.proxied,
+        priority,
+        comment: opts.comment,
+    });
+    log(renderRecord(result.record));
+}
+export async function runDnsEdit(client, projectId, domainName, recordId, opts, log = console.log) {
+    const body = {
+        type: opts.type,
+        name: opts.name,
+        content: opts.content,
+        ttl: numberOrUndefined(opts.ttl, 'ttl'),
+        proxied: opts.proxied,
+        priority: numberOrUndefined(opts.priority, 'priority'),
+        comment: opts.comment,
+    };
+    if (Object.values(body).every((value) => value === undefined)) {
+        throw new Error('Nothing to edit. Pass at least one record field.');
+    }
+    const domain = await resolveDomain(client, projectId, domainName);
+    const result = await client.patch(`/projects/${projectId}/domains/${domain.id}/dns-records/${recordId}`, body);
+    log(renderRecord(result.record));
+}
+export async function runDnsDelete(client, projectId, domainName, recordId, opts, log = console.log, confirmDelete = confirm) {
+    const domain = await resolveDomain(client, projectId, domainName);
+    const ok = opts.yes || (await confirmDelete(`Delete DNS record ${recordId} from ${domain.hostname}?`));
+    if (!ok) {
+        log('Cancelled.');
+        return;
+    }
+    await client.delete(`/projects/${projectId}/domains/${domain.id}/dns-records/${recordId}`, {
+        confirm: true,
+    });
+    log(`Deleted ${recordId}.`);
+}
+export function registerDns(program) {
+    const dns = program.command('dns').description('Manage DNS records through Newly backend');
+    dns
+        .command('list')
+        .argument('<domain>')
+        .option('--project <id>', 'project id (defaults to the linked directory)')
+        .description('List DNS records for a managed domain')
+        .action(async (domainName, opts) => {
+        try {
+            const { client, projectId } = makeClient(opts.project);
+            await runDnsList(client, projectId, domainName);
+        }
+        catch (e) {
+            console.error(friendlyApiError(e));
+            process.exitCode = 1;
+        }
+    });
+    dns
+        .command('add')
+        .argument('<domain>')
+        .requiredOption('--type <type>', 'record type')
+        .requiredOption('--name <name>', 'record name, or @ for apex')
+        .requiredOption('--content <content>', 'record content')
+        .option('--ttl <seconds>', 'record TTL', '300')
+        .option('--proxied', 'enable Cloudflare proxying')
+        .option('--priority <n>', 'MX priority')
+        .option('--comment <text>', 'record comment')
+        .option('--project <id>', 'project id (defaults to the linked directory)')
+        .description('Create a DNS record for a managed domain')
+        .action(async (domainName, opts) => {
+        try {
+            const { client, projectId } = makeClient(opts.project);
+            await runDnsAdd(client, projectId, domainName, opts);
+        }
+        catch (e) {
+            console.error(friendlyApiError(e));
+            process.exitCode = 1;
+        }
+    });
+    dns
+        .command('edit')
+        .argument('<domain>')
+        .argument('<record-id>')
+        .option('--type <type>', 'record type')
+        .option('--name <name>', 'record name, or @ for apex')
+        .option('--content <content>', 'record content')
+        .option('--ttl <seconds>', 'record TTL')
+        .option('--proxied', 'enable Cloudflare proxying')
+        .option('--no-proxied', 'disable Cloudflare proxying')
+        .option('--priority <n>', 'MX priority')
+        .option('--comment <text>', 'record comment')
+        .option('--project <id>', 'project id (defaults to the linked directory)')
+        .description('Edit a DNS record for a managed domain')
+        .action(async (domainName, recordId, opts) => {
+        try {
+            const { client, projectId } = makeClient(opts.project);
+            await runDnsEdit(client, projectId, domainName, recordId, opts);
+        }
+        catch (e) {
+            console.error(friendlyApiError(e));
+            process.exitCode = 1;
+        }
+    });
+    dns
+        .command('delete')
+        .argument('<domain>')
+        .argument('<record-id>')
+        .option('--project <id>', 'project id (defaults to the linked directory)')
+        .option('--yes', 'skip confirmation prompt', false)
+        .description('Delete a DNS record for a managed domain')
+        .action(async (domainName, recordId, opts) => {
+        try {
+            const { client, projectId } = makeClient(opts.project);
+            await runDnsDelete(client, projectId, domainName, recordId, opts);
+        }
+        catch (e) {
+            console.error(friendlyApiError(e));
+            process.exitCode = 1;
+        }
+    });
+}

package/dist/commands/domains.js

@@ -0,0 +1,201 @@
+import { stdin as input, stdout as output } from 'node:process';
+import { createInterface } from 'node:readline/promises';
+import { ApiClient, friendlyApiError } from '../api.js';
+import { requireCredentials, resolveProject } from '../config.js';
+function makeClient(project) {
+    const creds = requireCredentials();
+    return {
+        client: new ApiClient(creds.apiUrl, creds.token),
+        projectId: resolveProject(process.cwd(), project),
+        appUrl: creds.appUrl,
+    };
+}
+export function summarizeDomain(candidate) {
+    const name = String(candidate.name ?? candidate.domain ?? candidate.domain_name ?? '(unknown)');
+    const state = candidate.registrable === true || candidate.available === true
+        ? 'available'
+        : candidate.registrable === false || candidate.available === false
+            ? 'unavailable'
+            : 'unknown';
+    const pricing = candidate.pricing ? `  ${JSON.stringify(candidate.pricing)}` : '';
+    const reason = candidate.reason ? `  ${String(candidate.reason)}` : '';
+    return `${name}  ${state}${pricing}${reason}`;
+}
+export function renderProjectDomain(domain) {
+    return `${domain.id}  ${domain.hostname}  ${domain.status}  ${domain.ownership_mode}`;
+}
+async function confirm(prompt) {
+    const rl = createInterface({ input, output });
+    try {
+        const answer = (await rl.question(`${prompt} Type "yes" to continue: `)).trim().toLowerCase();
+        return answer === 'yes';
+    }
+    finally {
+        rl.close();
+    }
+}
+export async function runDomainSearch(client, query, limit = '10', log = console.log) {
+    const params = new URLSearchParams({ q: query, limit });
+    const result = (await client.get(`/domains/search?${params.toString()}`));
+    const candidates = result.domains ?? [];
+    log(candidates.length ? candidates.map(summarizeDomain).join('\n') : 'No suggestions.');
+}
+export async function runDomainCheck(client, domainNames, log = console.log) {
+    const result = (await client.post('/domains/check', { domains: domainNames }));
+    const candidates = result.domains ?? [];
+    log(candidates.length ? candidates.map(summarizeDomain).join('\n') : 'No results.');
+}
+export async function runDomainBuy(client, projectId, domainName, opts, log = console.log, confirmPurchase = confirm) {
+    const quoteResult = (await client.post(`/projects/${projectId}/domains/registrations/quote`, {
+        domain: domainName,
+        years: opts.years,
+    }));
+    const quote = quoteResult.quote;
+    log(JSON.stringify(quote, null, 2));
+    const ok = opts.yes ||
+        (await confirmPurchase(`Domain registrations are not refundable once complete. Buy ${domainName}?`));
+    if (!ok) {
+        log('Cancelled.');
+        return;
+    }
+    const appUrl = (opts.appUrl ?? 'https://newly.app').replace(/\/+$/, '');
+    const result = (await client.post(`/projects/${projectId}/domains/registrations/checkout`, {
+        domain: domainName,
+        years: opts.years,
+        success_url: `${appUrl}/project/${projectId}/website?domain_checkout=success`,
+        cancel_url: `${appUrl}/project/${projectId}/website?domain_checkout=cancel`,
+    }));
+    if (!result.checkout_url)
+        throw new Error('Backend did not return a checkout URL.');
+    log(`Checkout: ${result.checkout_url}`);
+    if (result.order?.id)
+        log(`Order: ${result.order.id} (${result.order.status ?? 'checkout_created'})`);
+}
+export async function runDomainList(client, projectId, log = console.log) {
+    const result = (await client.get(`/projects/${projectId}/domains`));
+    const projectDomains = result.domains ?? [];
+    log(projectDomains.length ? projectDomains.map(renderProjectDomain).join('\n') : 'No domains.');
+}
+export async function runDomainConnect(client, projectId, hostname, opts, log = console.log) {
+    const result = await client.post(`/projects/${projectId}/domains/connect`, {
+        hostname,
+        deployment_id: opts.deployment,
+        ownership_mode: opts.managed ? 'managed_cloudflare' : 'byo_dns',
+    });
+    log(renderProjectDomain(result.domain));
+    log(JSON.stringify(result.dns_instructions, null, 2));
+}
+export async function runDomainStatus(client, projectId, hostnameOrId, log = console.log) {
+    const list = (await client.get(`/projects/${projectId}/domains`));
+    const projectDomains = list.domains ?? [];
+    const domain = hostnameOrId
+        ? projectDomains.find((item) => item.id === hostnameOrId || item.hostname === hostnameOrId)
+        : projectDomains[0];
+    if (!domain)
+        throw new Error('Domain not found.');
+    const refreshed = await client.post(`/projects/${projectId}/domains/${domain.id}/refresh`, {});
+    log(renderProjectDomain(refreshed.domain));
+    if (refreshed.dns_instructions)
+        log(JSON.stringify(refreshed.dns_instructions, null, 2));
+}
+export function registerDomains(program) {
+    const domains = program.command('domains').description('Search, buy, and connect domains');
+    domains
+        .command('search')
+        .argument('<query>')
+        .option('--limit <n>', 'number of suggestions', '10')
+        .description('Search available domains through Cloudflare Registrar')
+        .action(async (query, opts) => {
+        try {
+            const creds = requireCredentials();
+            const client = new ApiClient(creds.apiUrl, creds.token);
+            await runDomainSearch(client, query, opts.limit);
+        }
+        catch (e) {
+            console.error(friendlyApiError(e));
+            process.exitCode = 1;
+        }
+    });
+    domains
+        .command('check')
+        .argument('<domains...>')
+        .description('Check domain availability through Cloudflare Registrar')
+        .action(async (domainNames) => {
+        try {
+            const creds = requireCredentials();
+            const client = new ApiClient(creds.apiUrl, creds.token);
+            await runDomainCheck(client, domainNames);
+        }
+        catch (e) {
+            console.error(friendlyApiError(e));
+            process.exitCode = 1;
+        }
+    });
+    domains
+        .command('buy')
+        .argument('<domain>')
+        .option('--years <n>', 'registration term in years', '1')
+        .option('--project <id>', 'project id (defaults to the linked directory)')
+        .option('--yes', 'confirm purchase without an interactive prompt', false)
+        .description('Buy a domain through Cloudflare Registrar')
+        .action(async (domainName, opts) => {
+        try {
+            const { client, projectId, appUrl } = makeClient(opts.project);
+            await runDomainBuy(client, projectId, domainName, {
+                years: Number(opts.years),
+                yes: opts.yes,
+                appUrl,
+            });
+        }
+        catch (e) {
+            console.error(friendlyApiError(e));
+            process.exitCode = 1;
+        }
+    });
+    domains
+        .command('list')
+        .option('--project <id>', 'project id (defaults to the linked directory)')
+        .description('List domains connected to a project')
+        .action(async (opts) => {
+        try {
+            const { client, projectId } = makeClient(opts.project);
+            await runDomainList(client, projectId);
+        }
+        catch (e) {
+            console.error(friendlyApiError(e));
+            process.exitCode = 1;
+        }
+    });
+    domains
+        .command('connect')
+        .argument('<hostname>')
+        .option('--project <id>', 'project id (defaults to the linked directory)')
+        .option('--deployment <id>', 'deployment id to serve')
+        .option('--managed', 'domain DNS is managed by Newly/Cloudflare', false)
+        .description('Connect an existing domain to the published website')
+        .action(async (hostname, opts) => {
+        try {
+            const { client, projectId } = makeClient(opts.project);
+            await runDomainConnect(client, projectId, hostname, opts);
+        }
+        catch (e) {
+            console.error(friendlyApiError(e));
+            process.exitCode = 1;
+        }
+    });
+    domains
+        .command('status')
+        .argument('[hostname-or-id]')
+        .option('--project <id>', 'project id (defaults to the linked directory)')
+        .description('Show or refresh connected domain status')
+        .action(async (hostnameOrId, opts) => {
+        try {
+            const { client, projectId } = makeClient(opts.project);
+            await runDomainStatus(client, projectId, hostnameOrId);
+        }
+        catch (e) {
+            console.error(friendlyApiError(e));
+            process.exitCode = 1;
+        }
+    });
+}

package/dist/commands/email.js

@@ -0,0 +1,86 @@
+import { ApiClient, friendlyApiError } from '../api.js';
+import { requireCredentials, resolveProject } from '../config.js';
+import { assertDevOnly } from './misc.js';
+function makeClient(project) {
+    const creds = requireCredentials();
+    return {
+        client: new ApiClient(creds.apiUrl, creds.token),
+        projectId: resolveProject(process.cwd(), project),
+    };
+}
+export async function getEmailStatus(client, projectId, env) {
+    return await client.get(`/newly_backend/email/status?project_id=${encodeURIComponent(projectId)}&env=${env}`);
+}
+export function formatEmailStatus(status) {
+    const lines = [
+        `email: ${status.configured ? 'configured' : 'not configured'}`,
+        `from: ${status.from ?? '(not set)'}`,
+    ];
+    if (status.requires_deploy)
+        lines.push('requires deploy: yes');
+    if (status.notes)
+        lines.push(`notes: ${status.notes}`);
+    return lines.join('\n');
+}
+export async function sendTestEmail(client, opts) {
+    return await client.post('/newly_backend/email/test', {
+        project_id: opts.projectId,
+        env: opts.env,
+        to: opts.to,
+        from: opts.from,
+        subject: opts.subject,
+        text: opts.text,
+        html: opts.html,
+    });
+}
+export function registerEmail(program) {
+    const email = program.command('email').description('Manage Newly Email');
+    email
+        .command('status')
+        .description('Show Newly Email configuration for this backend')
+        .option('--env <env>', 'dev or prod', 'dev')
+        .option('--project <id>', 'project id')
+        .action(async (opts) => {
+        try {
+            assertDevOnly(opts.env, 'email status');
+            const { client, projectId } = makeClient(opts.project);
+            console.log(formatEmailStatus(await getEmailStatus(client, projectId, opts.env)));
+        }
+        catch (e) {
+            console.error(friendlyApiError(e));
+            process.exitCode = 1;
+        }
+    });
+    email
+        .command('test')
+        .description('Send a test email through the deployed API service')
+        .requiredOption('--to <email>', 'recipient email address')
+        .option('--from <email>', 'sender email address; defaults to the backend sender setting')
+        .option('--subject <subject>', 'email subject', 'Newly email test')
+        .option('--text <text>', 'plain-text body', 'This is a test email from your Newly backend.')
+        .option('--html <html>', 'optional HTML body')
+        .option('--env <env>', 'dev or prod', 'dev')
+        .option('--project <id>', 'project id')
+        .action(async (opts) => {
+        try {
+            assertDevOnly(opts.env, 'email test');
+            const { client, projectId } = makeClient(opts.project);
+            const result = await sendTestEmail(client, {
+                projectId,
+                env: opts.env,
+                to: opts.to,
+                from: opts.from,
+                subject: opts.subject,
+                text: opts.text,
+                html: opts.html,
+            });
+            console.log(result.message_id
+                ? `Email sent. message_id=${result.message_id}`
+                : 'Email sent.');
+        }
+        catch (e) {
+            console.error(friendlyApiError(e));
+            process.exitCode = 1;
+        }
+    });
+}

package/dist/commands/link.js

@@ -0,0 +1,17 @@
+import { readProjectLink, writeProjectLink } from '../config.js';
+export function registerLink(program) {
+    program
+        .command('link')
+        .argument('<project-id>', 'Newly project id')
+        .description('Associate the current directory with a project (no download) so deploy/status/logs work here')
+        .action((projectId) => {
+        const dir = process.cwd();
+        const existing = readProjectLink(dir);
+        writeProjectLink(dir, {
+            projectId,
+            pulledSha: existing?.projectId === projectId ? existing.pulledSha : null,
+            pulledAt: new Date().toISOString(),
+        });
+        console.log(`Linked ${dir} to project ${projectId}. You can now run \`newly deploy\`, \`newly status\`, etc. here.`);
+    });
+}