@newly/cli 0.1.0 → 0.1.2

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/login.js

@@ -1,8 +1,8 @@
 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';
+import { clearCredentials, credentialsDisplayPath, saveCredentials } from '../config.js';
+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 });
@@ -128,7 +152,7 @@ export function registerLogin(program) {
                     appUrl: opts.appUrl,
                     expiresAt: Math.floor(Date.now() / 1000) + payload.expiresIn,
                 });
-                console.log('Logged in. Credentials saved to ~/.newly/credentials');
+                console.log(`Logged in. Credentials saved to ${credentialsDisplayPath()}`);
             }
             finally {
                 close();

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) => {