@zuvo/cli 0.1.7 → 0.1.8

package/README.md

@@ -30,6 +30,10 @@ zuvo hosting env set API_KEY=secret FOO=bar
 zuvo hosting env set --env-file ./.env.hosting
 zuvo hosting env unset API_KEY
 zuvo hosting secrets list   # alias for hosting env
+zuvo hosting domains
+zuvo hosting domains add app.example.com --app sklive-admin
+zuvo hosting domains verify app.example.com
+zuvo hosting domains rm app.example.com
 ```
 
 Token: Studio → Account → Access Tokens, or `zuvo login --token zpat_…`.  
@@ -39,3 +43,4 @@ API override: `ZUVO_API_URL` / `--api-url` (default `https://api.zuvodev.com`).
 - Hosting env keys must be `UPPER_SNAKE` (`^[A-Z][A-Z0-9_]{0,127}$`).
 - After `hosting env set|unset`, run `zuvo hosting deploy --wait` so the container picks up new vars.
 - `zuvo secrets` = project Edge Function secrets; `zuvo hosting env` = App Hosting container env.
+- Custom domains: add TXT `_zuvo-hosting-challenge.<host>` + CNAME → `app.zuvodev.com` or `sin.app.zuvodev.com`, then `domains verify`. Requires plan `allow_custom_domains`.

package/dist/hosting.js

@@ -86,3 +86,35 @@ export function formatFunctionLogLine(row) {
     ].filter(Boolean);
     return bits.join('  ');
 }
+export function normalizeHostnameInput(raw) {
+    return String(raw || '')
+        .trim()
+        .toLowerCase()
+        .replace(/^https?:\/\//, '')
+        .replace(/\/.*$/, '')
+        .replace(/\.$/, '');
+}
+export function formatDomainDnsInstructions(domain) {
+    const hostname = domain.hostname || '';
+    const txtName = domain.challenge_name || `_zuvo-hosting-challenge.${hostname}`;
+    const txtValue = domain.challenge_value || domain.verification_token || '';
+    const cnameTarget = domain.dns_cname_target || 'app.zuvodev.com';
+    return [
+        `Hostname: ${hostname}`,
+        `Status:   ${domain.status || 'unknown'}`,
+        '',
+        'Add these DNS records at your registrar:',
+        '',
+        `  TXT   ${txtName}`,
+        `        ${txtValue}`,
+        '',
+        `  CNAME ${hostname}`,
+        `        ${cnameTarget}`,
+        '',
+        'Then run: zuvo hosting domains verify ' + (hostname || '<hostname>'),
+    ].join('\n');
+}
+export function formatDomainListLine(domain) {
+    return [domain.id || '', domain.hostname || '', domain.status || '', domain.tls_status || '']
+        .join('\t');
+}

package/dist/index.js

@@ -4,7 +4,7 @@ import { apiRequest, ApiError } from './api.js';
 import { argvAfterCommand } from './argv.js';
 import { apiUrlFromEnv, deleteAccessToken, isAccessToken, requireLinkedRef, saveLinkedRef, } from './config.js';
 import { encodeFunctionForm, listFunctionSlugs, loadFunctionBundle } from './functions.js';
-import { formatFunctionLogLine, formatHostingLogLine, formatLogTimestamp, functionLogsSql, hostingLogsSql, parseSince, sortLogsChronological, } from './hosting.js';
+import { formatDomainDnsInstructions, formatDomainListLine, formatFunctionLogLine, formatHostingLogLine, formatLogTimestamp, functionLogsSql, hostingLogsSql, normalizeHostnameInput, parseSince, sortLogsChronological, } from './hosting.js';
 import { loginBrowser, loginWithToken } from './login.js';
 import { loadLocalMigrations, pendingMigrations } from './migrations.js';
 import { loadSecretsEnvFile, parseSecretArgs } from './secrets.js';
@@ -33,6 +33,10 @@ Commands:
   hosting env set NAME=VALUE [...] [--env-file <path>] [--app <appId|slug>]
   hosting env unset NAME [...] [--app <appId|slug>]
   hosting secrets …          Alias for hosting env …
+  hosting domains [list] [--app <appId|slug>]
+  hosting domains add <hostname> [--app <appId|slug>]
+  hosting domains verify <hostname|id> [--app <appId|slug>]
+  hosting domains rm <hostname|id> [--app <appId|slug>]
 
 Global:
   --api-url <url>     Default https://api.zuvodev.com (or ZUVO_API_URL)
@@ -656,6 +660,124 @@ async function cmdHostingEnv(apiUrl, argv) {
         throw new Error('Usage: zuvo hosting env list|set|unset … (alias: zuvo hosting secrets …)');
     }
 }
+async function fetchHostingDomains(apiUrl, ref, appId) {
+    return apiRequest(apiUrl, 'GET', `/platform/projects/${ref}/hosting/apps/${appId}/domains`);
+}
+function resolveDomain(domains, key) {
+    const needle = normalizeHostnameInput(key);
+    const match = domains.find((d) => d.id === key || (d.hostname && normalizeHostnameInput(d.hostname) === needle));
+    if (!match)
+        throw new Error(`Domain not found: ${key}`);
+    return match;
+}
+async function cmdHostingDomainsList(apiUrl, argv) {
+    const { values } = parseArgs({
+        args: argv,
+        options: {
+            app: { type: 'string' },
+            'api-url': { type: 'string' },
+        },
+        allowPositionals: true,
+        strict: false,
+    });
+    const ref = await requireLinkedRef();
+    const app = await resolveHostingApp(apiUrl, ref, typeof values.app === 'string' ? values.app : undefined);
+    const data = await fetchHostingDomains(apiUrl, ref, app.id);
+    if (data.platform_url)
+        console.error(`Platform URL: ${data.platform_url}`);
+    if (data.allow_custom_domains === false) {
+        console.error('Custom domains are not enabled for this organization plan.');
+    }
+    const domains = Array.isArray(data.domains) ? data.domains : [];
+    if (!domains.length) {
+        console.log('No custom domains.');
+        return;
+    }
+    for (const domain of domains)
+        console.log(formatDomainListLine(domain));
+}
+async function cmdHostingDomainsAdd(apiUrl, argv) {
+    const { values, positionals } = parseArgs({
+        args: argv,
+        options: {
+            app: { type: 'string' },
+            'api-url': { type: 'string' },
+        },
+        allowPositionals: true,
+        strict: false,
+    });
+    const hostname = normalizeHostnameInput(positionals[0] || '');
+    if (!hostname) {
+        throw new Error('Usage: zuvo hosting domains add <hostname> [--app <id|slug>]');
+    }
+    const ref = await requireLinkedRef();
+    const app = await resolveHostingApp(apiUrl, ref, typeof values.app === 'string' ? values.app : undefined);
+    const data = await apiRequest(apiUrl, 'POST', `/platform/projects/${ref}/hosting/apps/${app.id}/domains`, { json: { hostname } });
+    console.log(formatDomainDnsInstructions(data.domain || { hostname }));
+}
+async function cmdHostingDomainsVerify(apiUrl, argv) {
+    const { values, positionals } = parseArgs({
+        args: argv,
+        options: {
+            app: { type: 'string' },
+            'api-url': { type: 'string' },
+        },
+        allowPositionals: true,
+        strict: false,
+    });
+    const key = positionals[0];
+    if (!key) {
+        throw new Error('Usage: zuvo hosting domains verify <hostname|id> [--app <id|slug>]');
+    }
+    const ref = await requireLinkedRef();
+    const app = await resolveHostingApp(apiUrl, ref, typeof values.app === 'string' ? values.app : undefined);
+    const listed = await fetchHostingDomains(apiUrl, ref, app.id);
+    const domain = resolveDomain(listed.domains || [], key);
+    const data = await apiRequest(apiUrl, 'POST', `/platform/projects/${ref}/hosting/apps/${app.id}/domains/${domain.id}/verify`, { json: {} });
+    const updated = data.domain || domain;
+    console.log([updated.id, updated.hostname, updated.status, updated.tls_status || '']
+        .filter(Boolean)
+        .join('\t'));
+    if (updated.status && !['active', 'provisioning', 'verified'].includes(updated.status)) {
+        console.log(formatDomainDnsInstructions(updated));
+    }
+}
+async function cmdHostingDomainsRm(apiUrl, argv) {
+    const { values, positionals } = parseArgs({
+        args: argv,
+        options: {
+            app: { type: 'string' },
+            'api-url': { type: 'string' },
+        },
+        allowPositionals: true,
+        strict: false,
+    });
+    const key = positionals[0];
+    if (!key) {
+        throw new Error('Usage: zuvo hosting domains rm <hostname|id> [--app <id|slug>]');
+    }
+    const ref = await requireLinkedRef();
+    const app = await resolveHostingApp(apiUrl, ref, typeof values.app === 'string' ? values.app : undefined);
+    const listed = await fetchHostingDomains(apiUrl, ref, app.id);
+    const domain = resolveDomain(listed.domains || [], key);
+    await apiRequest(apiUrl, 'DELETE', `/platform/projects/${ref}/hosting/apps/${app.id}/domains/${domain.id}`);
+    console.log(`Removed ${domain.hostname || domain.id}`);
+}
+async function cmdHostingDomains(apiUrl, argv) {
+    const [action, ...rest] = argv;
+    if (!action || action === 'list' || action.startsWith('-')) {
+        await cmdHostingDomainsList(apiUrl, action?.startsWith('-') ? argv : rest);
+    }
+    else if (action === 'add')
+        await cmdHostingDomainsAdd(apiUrl, rest);
+    else if (action === 'verify')
+        await cmdHostingDomainsVerify(apiUrl, rest);
+    else if (action === 'rm' || action === 'remove' || action === 'delete')
+        await cmdHostingDomainsRm(apiUrl, rest);
+    else {
+        throw new Error('Usage: zuvo hosting domains [list|add|verify|rm] …');
+    }
+}
 async function main() {
     const argv = process.argv.slice(2);
     const global = parseGlobal(argv);
@@ -700,6 +822,8 @@ async function main() {
             await cmdHostingDeployLogs(apiUrl, argvAfterCommand(argv, 'hosting', sub));
         else if (command === 'hosting' && (sub === 'env' || sub === 'secrets'))
             await cmdHostingEnv(apiUrl, argvAfterCommand(argv, 'hosting', sub));
+        else if (command === 'hosting' && (sub === 'domains' || sub === 'domain'))
+            await cmdHostingDomains(apiUrl, argvAfterCommand(argv, 'hosting', sub));
         else {
             console.error(usage());
             process.exit(command ? 1 : 0);

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@zuvo/cli",
-  "version": "0.1.7",
+  "version": "0.1.8",
   "type": "module",
-  "description": "Zuvo CLI — login, link, functions/hosting deploy, secrets, env, db push, and logs",
+  "description": "Zuvo CLI — login, link, functions/hosting deploy, secrets, env, domains, db push, and logs",
   "license": "MIT",
   "bin": {
     "zuvo": "bin/zuvo.js"