@zuvo/cli 0.1.6 → 0.1.8

package/README.md

@@ -8,6 +8,9 @@ zuvo login
 zuvo projects list
 zuvo link --project <ref>
 zuvo functions deploy
+zuvo functions logs
+zuvo functions logs hello --since 6h
+zuvo functions logs -f
 zuvo secrets set OPENAI_API_KEY=sk-…
 zuvo secrets set --env-file ./supabase/.env.local
 zuvo secrets list
@@ -27,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_…`.  
@@ -36,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

@@ -56,3 +56,65 @@ export function hostingLogsSql(limit) {
     const safe = Math.min(Math.max(1, Math.floor(limit)), 5_000);
     return `select id, timestamp, event_message from hosting_logs order by timestamp desc limit ${safe}`;
 }
+/** Slug or UUID safe to embed in analytics SQL. */
+export function assertSafeFunctionKey(key) {
+    const trimmed = key.trim();
+    if (!/^[a-zA-Z0-9_-]{1,128}$/.test(trimmed)) {
+        throw new Error(`Invalid function name: ${key} (use slug or UUID: letters, digits, _, -)`);
+    }
+    return trimmed;
+}
+export function functionLogsSql(limit, functionKey) {
+    const safe = Math.min(Math.max(1, Math.floor(limit)), 5_000);
+    const where = functionKey
+        ? ` where metadata.function_id = '${assertSafeFunctionKey(functionKey)}'`
+        : '';
+    return `select id, timestamp, event_message from function_logs${where} order by timestamp desc limit ${safe}`;
+}
+export function formatFunctionLogLine(row) {
+    const ts = formatLogTimestamp(row.timestamp);
+    const metaFn = row.metadata && typeof row.metadata.function_id === 'string'
+        ? row.metadata.function_id
+        : '';
+    const fn = row.function_id || metaFn;
+    const bits = [
+        ts,
+        fn ? `[${fn}]` : '',
+        row.method || '',
+        row.status_code != null ? String(row.status_code) : '',
+        row.event_message ?? '',
+    ].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 { formatHostingLogLine, formatLogTimestamp, 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';
@@ -18,6 +18,7 @@ Commands:
   link --project <ref>
   functions list
   functions deploy [slug]
+  functions logs [slug] [--limit N] [--since 1h|30m|ISO] [-f|--follow]
   secrets list
   secrets set NAME=VALUE [NAME=VALUE ...]
   secrets set --env-file <path>
@@ -32,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)
@@ -151,6 +156,84 @@ async function deployOne(apiUrl, ref, slug) {
     const meta = await apiRequest(apiUrl, 'POST', `/v1/projects/${ref}/functions/deploy`, { form, query: { slug: bundle.slug } });
     console.log(`Deployed ${meta.slug || bundle.slug}${meta.version != null ? ` (v${meta.version})` : ''}`);
 }
+async function fetchFunctionLogs(apiUrl, ref, opts) {
+    const body = {
+        sql: functionLogsSql(opts.limit, opts.functionKey),
+    };
+    if (opts.since)
+        body.iso_timestamp_start = opts.since.toISOString();
+    const data = await apiRequest(apiUrl, 'POST', `/platform/projects/${ref}/analytics/endpoints/logs.all`, { json: body });
+    return Array.isArray(data?.result) ? data.result : [];
+}
+async function cmdFunctionsLogs(apiUrl, argv) {
+    const { values, positionals } = parseArgs({
+        args: argv,
+        options: {
+            limit: { type: 'string' },
+            since: { type: 'string' },
+            follow: { type: 'boolean', short: 'f' },
+            'api-url': { type: 'string' },
+        },
+        allowPositionals: true,
+        strict: false,
+    });
+    const ref = await requireLinkedRef();
+    const functionKey = positionals.find((arg) => !arg.startsWith('-'));
+    const limitRaw = typeof values.limit === 'string' ? Number(values.limit) : 100;
+    const limit = Number.isFinite(limitRaw) ? limitRaw : 100;
+    const since = typeof values.since === 'string' && values.since.trim()
+        ? parseSince(values.since)
+        : parseSince('1h');
+    const follow = Boolean(values.follow);
+    const seen = new Set();
+    const printNew = (rows) => {
+        for (const row of sortLogsChronological(rows)) {
+            const key = row.id || `${formatFunctionLogLine(row)}`;
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            console.log(formatFunctionLogLine(row));
+        }
+    };
+    const initial = await fetchFunctionLogs(apiUrl, ref, {
+        limit,
+        since,
+        functionKey,
+    });
+    if (!initial.length && !follow) {
+        console.log(functionKey
+            ? `No edge function logs for ${functionKey} in range.`
+            : 'No edge function logs in range.');
+        return;
+    }
+    printNew(initial);
+    if (!follow)
+        return;
+    let cursor = since;
+    for (const row of sortLogsChronological(initial)) {
+        const iso = formatLogTimestamp(row.timestamp);
+        const parsed = iso ? new Date(iso) : null;
+        if (parsed && !Number.isNaN(parsed.getTime()) && parsed > cursor)
+            cursor = parsed;
+    }
+    console.error('Following edge function logs… (Ctrl+C to stop)');
+    for (;;) {
+        await new Promise((r) => setTimeout(r, 2_500));
+        const nextSince = new Date(Math.max(0, cursor.getTime() - 1_000));
+        const rows = await fetchFunctionLogs(apiUrl, ref, {
+            limit: Math.max(limit, 200),
+            since: nextSince,
+            functionKey,
+        });
+        printNew(rows);
+        for (const row of sortLogsChronological(rows)) {
+            const iso = formatLogTimestamp(row.timestamp);
+            const parsed = iso ? new Date(iso) : null;
+            if (parsed && !Number.isNaN(parsed.getTime()) && parsed > cursor)
+                cursor = parsed;
+        }
+    }
+}
 async function cmdFunctionsDeploy(apiUrl, argv) {
     const ref = await requireLinkedRef();
     const slug = argv.find((arg) => !arg.startsWith('-'));
@@ -577,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);
@@ -599,6 +800,8 @@ async function main() {
             await cmdFunctionsList(apiUrl);
         else if (command === 'functions' && sub === 'deploy')
             await cmdFunctionsDeploy(apiUrl, argvAfterCommand(argv, 'functions', 'deploy'));
+        else if (command === 'functions' && sub === 'logs')
+            await cmdFunctionsLogs(apiUrl, argvAfterCommand(argv, 'functions', 'logs'));
         else if (command === 'secrets' && (sub === 'list' || !sub))
             await cmdSecretsList(apiUrl);
         else if (command === 'secrets' && sub === 'set')
@@ -619,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.6",
+  "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"