@newly/cli 0.1.0 → 0.1.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/login.js

@@ -2,7 +2,7 @@ import http from 'node:http';
 import crypto from 'node:crypto';
 import { spawn } from 'node:child_process';
 import { clearCredentials, saveCredentials } from '../config.js';
-const DEFAULT_APP_URL = 'https://newly.app';
+const DEFAULT_APP_URL = process.env.NEWLY_APP_URL ?? 'https://newly.app';
 const LOGIN_TIMEOUT_MS = 5 * 60 * 1000;
 export async function startCallbackServer(state, appOrigin, timeoutMs) {
     let resolvePayload;
@@ -96,8 +96,32 @@ export function registerLogin(program) {
         .description('Log in with your Newly account via the browser')
         .option('--app-url <url>', 'Newly web app URL', DEFAULT_APP_URL)
         .option('--manual', 'paste the credential from the browser instead of using the local callback', false)
+        .option('--api-url <url>', 'explicit API URL (skips browser; use with --token)')
+        .option('--token <token>', 'explicit credential token (skips browser; use with --api-url)')
+        .option('--expires-in <seconds>', 'session lifetime when using --token (default 7 days)', (v) => Number(v), 604800)
         .action(async (opts) => {
         try {
+            const hasApiUrl = typeof opts.apiUrl === 'string' && opts.apiUrl.length > 0;
+            const hasToken = typeof opts.token === 'string' && opts.token.length > 0;
+            if (hasApiUrl !== hasToken) {
+                throw new Error('--api-url and --token must be provided together for headless login.');
+            }
+            if (hasApiUrl && hasToken) {
+                try {
+                    new URL(opts.apiUrl);
+                }
+                catch {
+                    throw new Error(`--api-url is not a valid URL: ${opts.apiUrl}`);
+                }
+                saveCredentials({
+                    token: opts.token,
+                    apiUrl: opts.apiUrl,
+                    appUrl: opts.appUrl,
+                    expiresAt: Math.floor(Date.now() / 1000) + opts.expiresIn,
+                });
+                console.log(`Logged in headlessly. Credentials written for API ${opts.apiUrl}.`);
+                return;
+            }
             if (opts.manual) {
                 const { createInterface } = await import('node:readline/promises');
                 const rl = createInterface({ input: process.stdin, output: process.stdout });

package/dist/commands/misc.js

@@ -30,13 +30,34 @@ export function resolveLogWindow(opts, now = Date.now()) {
         validateIso(opts.end);
     return { start, end: opts.end };
 }
-export async function fetchLogs(client, projectId, env, service, n, bounds = {}) {
-    const body = { project_id: projectId, env, service, n };
+export function formatLogEntry(e) {
+    if (!e || typeof e !== 'object')
+        return String(e);
+    const ts = e.ts ?? '-';
+    const sev = (e.severity ?? 'OK').padEnd(5);
+    const trace = e.trace_id ? ` trace=${e.trace_id.slice(0, 16)}` : '';
+    const name = e.name ?? '';
+    return `${ts} ${sev} ${name}${trace}`.trimEnd();
+}
+export async function fetchLogs(client, projectId, env, service, pageSize, bounds = {}, filters = {}) {
+    const params = new URLSearchParams();
+    params.set('env', env);
+    params.set('service', service);
+    params.set('page_size', String(pageSize));
     if (bounds.start)
-        body.start = bounds.start;
+        params.set('start', bounds.start);
     if (bounds.end)
-        body.end = bounds.end;
-    const out = await client.post('/newly_backend/tail_logs', body);
+        params.set('end', bounds.end);
+    if (filters.severityMin)
+        params.set('severity_min', filters.severityMin);
+    if (filters.traceId)
+        params.set('trace_id', filters.traceId);
+    if (filters.textSearch)
+        params.set('text_search', filters.textSearch);
+    const out = await client.get(`/newly_backend/logs/${encodeURIComponent(projectId)}?${params.toString()}`);
+    if (Array.isArray(out.entries)) {
+        return out.entries.map((e) => formatLogEntry(e)).join('\n');
+    }
     if (typeof out.logs === 'string')
         return out.logs;
     if (Array.isArray(out.lines))
@@ -75,18 +96,24 @@ export function registerMisc(program) {
         .command('logs')
         .description('Tail backend service logs')
         .option('--env <env>', 'dev or prod', 'dev')
-        .option('--service <service>', 'api or auth', 'api')
-        .option('-n, --lines <n>', 'number of lines', '200')
+        .option('--service <service>', 'api | auth', 'api')
+        .option('-n, --lines <n>', 'page size (number of log entries to fetch)', '200')
         .option('--since <duration>', 'relative window, e.g. 5m, 1h, 30s')
         .option('--start <iso>', 'window start (ISO 8601 timestamp)')
         .option('--end <iso>', 'window end (ISO 8601 timestamp)')
+        .option('--severity <min>', 'min severity: ok | warn | error')
+        .option('--trace <id>', 'restrict to a single trace_id')
+        .option('--search <text>', 'substring filter on the entry name')
         .option('--project <id>', 'project id')
         .action(async (opts) => {
         try {
             assertDevOnly(opts.env, 'logs');
+            if (opts.service !== 'api' && opts.service !== 'auth') {
+                throw new Error(`--service must be 'api' or 'auth' (got ${JSON.stringify(opts.service)})`);
+            }
             const bounds = resolveLogWindow(opts);
             const { client, projectId } = makeClient(opts.project);
-            console.log(await fetchLogs(client, projectId, opts.env, opts.service, Number(opts.lines), bounds));
+            console.log(await fetchLogs(client, projectId, opts.env, opts.service, Number(opts.lines), bounds, { severityMin: opts.severity, traceId: opts.trace, textSearch: opts.search }));
         }
         catch (e) {
             console.error(friendlyApiError(e));
@@ -97,7 +124,7 @@ export function registerMisc(program) {
     secrets
         .command('list')
         .option('--env <env>', 'dev or prod', 'dev')
-        .option('--service <service>', 'api or auth', 'api')
+        .option('--service <service>', 'backend service name', 'worker')
         .option('--project <id>', 'project id')
         .action(async (opts) => {
         try {
@@ -115,7 +142,7 @@ export function registerMisc(program) {
         .argument('<key>')
         .argument('<value>')
         .option('--env <env>', 'dev or prod', 'dev')
-        .option('--service <service>', 'api or auth', 'api')
+        .option('--service <service>', 'backend service name', 'worker')
         .option('--project <id>', 'project id')
         .action(async (key, value, opts) => {
         try {
@@ -131,7 +158,7 @@ export function registerMisc(program) {
     });
     const db = program.command('db').description('Database helpers');
     db.command('url')
-        .description('Print a readonly Postgres URL for the backend database')
+        .description('Print a readonly URL for the Newly DB')
         .option('--env <env>', 'dev or prod', 'dev')
         .option('--project <id>', 'project id')
         .action(async (opts) => {

package/dist/commands/services.js

@@ -0,0 +1,39 @@
+import { friendlyApiError } from '../api.js';
+import { readProjectLink, resolveProject } from '../config.js';
+import { readBackendServices, serviceUrl } from '../services-manifest.js';
+export function renderServices(services = readBackendServices(process.cwd()), opts = {}) {
+    const lines = ['name  type    path          public  url'];
+    for (const service of services) {
+        const isPublic = service.public !== false;
+        const url = opts.projectId && isPublic ? serviceUrl(opts.projectId, opts.env ?? 'dev', service.name) : '-';
+        lines.push([
+            service.name.padEnd(5),
+            service.type.padEnd(7),
+            service.path.padEnd(13),
+            String(isPublic).padEnd(7),
+            url,
+        ].join(' '));
+    }
+    return lines.join('\n');
+}
+export function registerServices(program) {
+    const services = program.command('services').description('Inspect backend services');
+    services
+        .command('list')
+        .description('List backend services from backend/newly.services.json')
+        .option('--env <env>', 'dev or prod', 'dev')
+        .option('--project <id>', 'project id (defaults to the linked directory when present)')
+        .action(async (opts) => {
+        try {
+            if (opts.env !== 'dev' && opts.env !== 'prod')
+                throw new Error('--env must be dev or prod');
+            const projectId = opts.project ?? readProjectLink(process.cwd())?.projectId;
+            const resolved = projectId ? resolveProject(process.cwd(), projectId) : undefined;
+            console.log(renderServices(readBackendServices(process.cwd()), { projectId: resolved, env: opts.env }));
+        }
+        catch (e) {
+            console.error(friendlyApiError(e));
+            process.exitCode = 1;
+        }
+    });
+}

package/dist/commands/stack.js

@@ -1,25 +1,27 @@
 import { ApiClient, friendlyApiError } from '../api.js';
 import { requireCredentials, resolveProject } from '../config.js';
+export async function getStack(client, projectId) {
+    return (await client.get(`/newly_backend/stack/${projectId}`));
+}
+export function formatStack(out) {
+    const stack = out.stack ?? 'unknown';
+    const cli = out.cli_deployable
+        ? '✓ CLI-deployable — Newly backend'
+        : '✗ not CLI-deployable — use the Newly web app to deploy this project.';
+    return `stack: ${stack}\n${cli}`;
+}
 export function registerStack(program) {
     program
         .command('stack')
-        .description('Show which backend stack a project uses (newly-backend or specular)')
+        .description('Show which backend type a project uses and whether it supports CLI deploys')
         .option('--project <id>', 'project id (defaults to the linked directory)')
         .action(async (opts) => {
         try {
             const creds = requireCredentials();
             const projectId = resolveProject(process.cwd(), opts.project);
             const client = new ApiClient(creds.apiUrl, creds.token);
-            const out = await client.get(`/newly_backend/stack/${projectId}`);
-            const stack = out.stack ?? 'unknown';
-            console.log(`stack: ${stack}`);
-            if (out.cli_deployable) {
-                console.log('✓ CLI-deployable — Python api-service + Node auth-service');
-            }
-            else {
-                console.log('✗ not CLI-deployable — this project is on the Specular stack ' +
-                    '(a single Node/drizzle backend). `newly deploy` supports only the newly-backend stack.');
-            }
+            const out = await getStack(client, projectId);
+            console.log(formatStack(out));
         }
         catch (e) {
             console.error(friendlyApiError(e));

package/dist/commands/status.js

@@ -22,23 +22,23 @@ function renderProvisioningStages(s) {
             complete: true,
         },
         {
-            label: 'Cloud environment assigned',
-            note: 'dedicated cloud environment allocated for your backend',
+            label: 'Newly server assigned',
+            note: 'Newly server workspace allocated for your backend',
             complete: s.cloud_env_assigned,
         },
         {
-            label: 'Infrastructure provisioned',
-            note: 'container registry, storage buckets, IAM roles set up',
-            complete: s.neon_ready,
+            label: 'Newly resources provisioned',
+            note: 'Newly storage and backend services provisioned',
+            complete: s.database_ready,
         },
         {
-            label: 'Database created',
-            note: 'Postgres database ready for your API service',
-            complete: s.neon_ready,
+            label: 'Newly DB created',
+            note: 'Newly DB ready for your backend',
+            complete: s.database_ready,
         },
         {
-            label: 'Environment secrets wired',
-            note: 'DB credentials, API keys and auth tokens encrypted and stored',
+            label: 'Backend configuration stored',
+            note: 'Newly DB credentials, API keys, and auth settings encrypted and stored',
             complete: s.secrets_wired,
         },
         {