@zuvo/cli 0.1.9 → 0.1.11

package/README.md

@@ -8,6 +8,8 @@ zuvo login
 zuvo projects list
 zuvo link --project <ref>
 zuvo functions deploy
+# also uploads supabase/functions/_shared (and other _* modules) with each deploy
+zuvo functions deploy hello
 zuvo functions logs
 zuvo functions logs hello --since 6h
 zuvo functions logs -f
@@ -18,6 +20,9 @@ zuvo secrets unset OPENAI_API_KEY
 zuvo db push
 
 # App Hosting
+zuvo github repos [--search my-app]
+zuvo hosting create --repo owner/my-app --name admin --deploy --wait
+zuvo hosting create                    # interactive repo picker (TTY)
 zuvo hosting apps
 zuvo hosting deploy --wait
 zuvo hosting deploy --commit abc1234 --app my-app
@@ -40,6 +45,10 @@ zuvo hosting domains rm app.example.com
 Token: Studio → Account → Access Tokens, or `zuvo login --token zpat_…`.  
 API override: `ZUVO_API_URL` / `--api-url` (default `https://api.zuvodev.com`).
 
+**Documentation:** [docs.zuvodev.com](https://docs.zuvodev.com)
+
+**App runtime clients** (not this CLI): [@zuvo/js](https://docs.zuvodev.com/guides/client-libraries/javascript), [Flutter / Swift / Kotlin](https://docs.zuvodev.com/guides/client-libraries) — or official Supabase SDKs against your Zuvo project URL.
+
 **Notes**
 - 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.

package/dist/functions.js

@@ -30,6 +30,31 @@ export async function listFunctionSlugs(cwd = process.cwd()) {
         return [];
     }
 }
+/** Underscore-prefixed dirs (e.g. `_shared`) — not deployable functions, shared imports. */
+export async function loadSharedModules(cwd = process.cwd()) {
+    const root = path.join(cwd, 'supabase', 'functions');
+    let entries;
+    try {
+        entries = await readdir(root, { withFileTypes: true });
+    }
+    catch {
+        return [];
+    }
+    const dirs = entries
+        .filter((ent) => ent.isDirectory() &&
+        ent.name.startsWith('_') &&
+        !ent.name.startsWith('.') &&
+        /^_[a-z0-9][a-z0-9_-]{0,62}$/i.test(ent.name))
+        .map((ent) => ent.name)
+        .sort();
+    const out = [];
+    for (const name of dirs) {
+        const files = await walkFiles(path.join(root, name));
+        if (files.length)
+            out.push({ name, files });
+    }
+    return out;
+}
 export async function loadFunctionBundle(cwd, slug) {
     const dir = path.join(cwd, 'supabase', 'functions', slug);
     const info = await stat(dir).catch(() => null);
@@ -68,5 +93,10 @@ export function encodeFunctionForm(input) {
     for (const file of input.files) {
         form.append('file', new Blob([file.content], { type: 'text/plain' }), file.name);
     }
+    for (const mod of input.sharedModules || []) {
+        for (const file of mod.files) {
+            form.append('shared', new Blob([file.content], { type: 'text/plain' }), `${mod.name}/${file.name}`);
+        }
+    }
     return form;
 }

package/dist/hosting-apps.js

@@ -0,0 +1,75 @@
+/** Normalize `owner/repo`, URL, or `.git` suffix into `owner/repo`. */
+export function normalizeRepoSelector(input) {
+    let value = String(input || '').trim();
+    if (!value)
+        return '';
+    value = value.replace(/^git@github\.com:/i, '');
+    value = value.replace(/^https?:\/\/(?:www\.)?github\.com\//i, '');
+    value = value.replace(/\.git$/i, '');
+    value = value.replace(/\/+$/, '');
+    return value.toLowerCase();
+}
+export function parseRepoSelector(input) {
+    const full = normalizeRepoSelector(input);
+    const parts = full.split('/').filter(Boolean);
+    if (parts.length < 2) {
+        throw new Error(`Invalid repo: ${input} (use owner/repo)`);
+    }
+    const repo = parts.pop();
+    const owner = parts.join('/');
+    if (!owner || !repo)
+        throw new Error(`Invalid repo: ${input} (use owner/repo)`);
+    return { owner, repo, full: `${owner}/${repo}` };
+}
+export function matchGithubRepo(repos, selector) {
+    const want = normalizeRepoSelector(selector);
+    if (!want)
+        return undefined;
+    const exact = repos.find((repo) => normalizeRepoSelector(repo.name) === want);
+    if (exact)
+        return exact;
+    const tail = want.split('/').pop() || want;
+    const byTail = repos.filter((repo) => {
+        const name = normalizeRepoSelector(repo.name);
+        return name === tail || name.endsWith(`/${tail}`);
+    });
+    if (byTail.length === 1)
+        return byTail[0];
+    return undefined;
+}
+export function findProjectConnectionForRepo(connections, projectRef, repoFullName) {
+    const want = normalizeRepoSelector(repoFullName);
+    return connections.find((row) => {
+        const repoName = normalizeRepoSelector(String(row.repository?.name || ''));
+        const ref = String(row.project?.ref || '');
+        return repoName === want && (!ref || ref === projectRef);
+    });
+}
+export function defaultAppNameFromRepo(repoFullName) {
+    const parsed = parseRepoSelector(repoFullName);
+    return parsed.repo.replace(/[^a-zA-Z0-9-]+/g, '-').replace(/^-+|-+$/g, '') || 'app';
+}
+export function assertSafeAppName(name) {
+    const trimmed = name.trim();
+    if (!trimmed)
+        throw new Error('App name is required');
+    if (trimmed.length > 64)
+        throw new Error('App name is too long (max 64 characters)');
+    return trimmed;
+}
+export function buildHostingAppCreateBody(input) {
+    const body = {
+        name: assertSafeAppName(input.name),
+        github_connection_id: input.github_connection_id,
+        branch: input.branch.trim() || 'main',
+    };
+    if (input.slug?.trim())
+        body.slug = input.slug.trim();
+    if (input.root_dir != null)
+        body.root_dir = input.root_dir.trim();
+    return body;
+}
+export function formatGithubRepoLine(repo, index) {
+    const prefix = index == null ? '' : `${index + 1}. `;
+    return `${prefix}${repo.name}  (${repo.default_branch || 'main'})`;
+}

package/dist/index.js

@@ -1,9 +1,12 @@
 #!/usr/bin/env node
 import { parseArgs } from 'node:util';
+import { createInterface } from 'node:readline/promises';
+import { stdin as input, stderr as output } from 'node:process';
 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 { encodeFunctionForm, listFunctionSlugs, loadFunctionBundle, loadSharedModules, } from './functions.js';
+import { buildHostingAppCreateBody, defaultAppNameFromRepo, findProjectConnectionForRepo, formatGithubRepoLine, matchGithubRepo, parseRepoSelector, } from './hosting-apps.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';
@@ -24,6 +27,8 @@ Commands:
   secrets set --env-file <path>
   secrets unset NAME [NAME ...]
   db push
+  github repos [--search <q>]
+  hosting create [--repo owner/name] [--name <app>] [--slug <slug>] [--branch main] [--root-dir <path>] [--connection-id <uuid>] [--deploy] [--wait] [--yes]
   hosting apps
   hosting deployments [--app <appId|slug>]
   hosting deploy [--app <appId|slug>] [--commit <sha>] [--wait]
@@ -133,7 +138,7 @@ async function cmdLink(apiUrl, argv) {
     if (!ref)
         throw new Error('Missing --project <ref>');
     const project = await apiRequest(apiUrl, 'GET', `/v1/projects/${ref}`);
-    const linked = project.ref || project.id || ref;
+    const linked = String(project.ref || project.id || ref);
     await saveLinkedRef(linked);
     console.log(`Linked to project ${linked}`);
 }
@@ -150,11 +155,15 @@ async function cmdFunctionsList(apiUrl) {
             .join('\t'));
     }
 }
-async function deployOne(apiUrl, ref, slug) {
+async function deployOne(apiUrl, ref, slug, sharedModules) {
     const bundle = await loadFunctionBundle(process.cwd(), slug);
-    const form = encodeFunctionForm(bundle);
+    const shared = sharedModules ?? (await loadSharedModules());
+    const form = encodeFunctionForm({ ...bundle, sharedModules: shared });
     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})` : ''}`);
+    const sharedNote = shared.length
+        ? ` (+${shared.map((m) => m.name).join(', ')})`
+        : '';
+    console.log(`Deployed ${meta.slug || bundle.slug}${meta.version != null ? ` (v${meta.version})` : ''}${sharedNote}`);
 }
 async function fetchFunctionLogs(apiUrl, ref, opts) {
     const body = {
@@ -241,11 +250,15 @@ async function cmdFunctionsDeploy(apiUrl, argv) {
     if (!slugs.length) {
         throw new Error('No functions to deploy (expected supabase/functions/<slug>).');
     }
+    const sharedModules = await loadSharedModules();
+    if (sharedModules.length) {
+        console.log(`Including shared modules: ${sharedModules.map((m) => m.name).join(', ')}`);
+    }
     const failures = [];
     for (let i = 0; i < slugs.length; i++) {
         const name = slugs[i];
         try {
-            await deployOne(apiUrl, ref, name);
+            await deployOne(apiUrl, ref, name, sharedModules);
         }
         catch (error) {
             const message = error instanceof Error ? error.message : String(error);
@@ -336,6 +349,80 @@ async function cmdDbPush(apiUrl) {
         console.log(`Applied ${migration.filename}`);
     }
 }
+async function loadLinkedProject(apiUrl) {
+    const ref = await requireLinkedRef();
+    const project = await apiRequest(apiUrl, 'GET', `/v1/projects/${ref}`);
+    const orgId = Number(project.organization_id || 0);
+    if (!orgId)
+        throw new Error('Could not resolve organization for linked project');
+    return { ref, project, orgId };
+}
+async function listGithubRepos(apiUrl, search) {
+    const data = await apiRequest(apiUrl, 'GET', '/integrations/github/repositories', {
+        query: search?.trim() ? { q: search.trim() } : undefined,
+    });
+    if (data.needs_reauthorization) {
+        throw new Error('GitHub is not authorized for your account. Connect GitHub in Studio → Integrations, then retry.');
+    }
+    return Array.isArray(data.repositories) ? data.repositories : [];
+}
+async function listGithubConnections(apiUrl, organizationId, projectRef) {
+    const data = await apiRequest(apiUrl, 'GET', '/integrations/github/connections', { query: { organization_id: String(organizationId), project_ref: projectRef } });
+    return Array.isArray(data.connections) ? data.connections : [];
+}
+async function pickGithubRepo(repos) {
+    if (!repos.length)
+        throw new Error('No GitHub repositories found for your account.');
+    if (repos.length === 1)
+        return repos[0];
+    for (let i = 0; i < repos.length; i += 1) {
+        console.error(formatGithubRepoLine(repos[i], i));
+    }
+    const rl = createInterface({ input, output });
+    try {
+        const answer = (await rl.question('Select repo number: ')).trim();
+        const index = Number(answer);
+        if (!Number.isFinite(index) || index < 1 || index > repos.length) {
+            throw new Error('Invalid selection');
+        }
+        return repos[index - 1];
+    }
+    finally {
+        rl.close();
+    }
+}
+async function resolveGithubRepo(apiUrl, selector, searchHint) {
+    if (selector?.trim()) {
+        const parsed = parseRepoSelector(selector);
+        const repos = await listGithubRepos(apiUrl, parsed.repo);
+        const match = matchGithubRepo(repos, parsed.full);
+        if (!match) {
+            throw new Error(`Repository not found or not accessible: ${parsed.full}`);
+        }
+        return match;
+    }
+    if (!input.isTTY) {
+        throw new Error('Pass --repo owner/name (non-interactive shell).');
+    }
+    const repos = await listGithubRepos(apiUrl, searchHint);
+    return pickGithubRepo(repos.slice(0, 30));
+}
+async function ensureGithubConnection(apiUrl, projectRef, organizationId, repo) {
+    const connections = await listGithubConnections(apiUrl, organizationId, projectRef);
+    const existing = findProjectConnectionForRepo(connections, projectRef, repo.name);
+    if (existing?.id)
+        return existing.id;
+    const created = await apiRequest(apiUrl, 'POST', '/integrations/github/connections', {
+        json: {
+            project_ref: projectRef,
+            repository_id: repo.id,
+            installation_id: repo.installation_id,
+        },
+    });
+    if (!created?.id)
+        throw new Error('Failed to attach GitHub repository to project');
+    return created.id;
+}
 async function listHostingApps(apiUrl, ref) {
     const data = await apiRequest(apiUrl, 'GET', `/platform/projects/${ref}/hosting/apps`);
     return Array.isArray(data?.apps) ? data.apps : [];
@@ -360,6 +447,125 @@ async function listHostingDeployments(apiUrl, ref, appId) {
     const data = await apiRequest(apiUrl, 'GET', `/platform/projects/${ref}/hosting/apps/${appId}/deployments`);
     return Array.isArray(data?.deployments) ? data.deployments : [];
 }
+async function cmdGithubRepos(apiUrl, argv) {
+    const { values } = parseArgs({
+        args: argv,
+        options: {
+            search: { type: 'string' },
+            q: { type: 'string' },
+            'api-url': { type: 'string' },
+        },
+        allowPositionals: true,
+        strict: false,
+    });
+    const search = (typeof values.search === 'string' && values.search) ||
+        (typeof values.q === 'string' && values.q) ||
+        undefined;
+    const repos = await listGithubRepos(apiUrl, search);
+    if (!repos.length) {
+        console.log('No repositories found.');
+        return;
+    }
+    for (let i = 0; i < repos.length; i += 1) {
+        console.log([repos[i].id, repos[i].name, repos[i].default_branch || 'main'].join('\t'));
+    }
+}
+async function cmdHostingCreate(apiUrl, argv) {
+    const { values, positionals } = parseArgs({
+        args: argv,
+        options: {
+            repo: { type: 'string' },
+            name: { type: 'string' },
+            slug: { type: 'string' },
+            branch: { type: 'string' },
+            'root-dir': { type: 'string' },
+            'connection-id': { type: 'string' },
+            deploy: { type: 'boolean' },
+            wait: { type: 'boolean' },
+            yes: { type: 'boolean', short: 'y' },
+            'api-url': { type: 'string' },
+        },
+        allowPositionals: true,
+        strict: false,
+    });
+    const { ref, orgId } = await loadLinkedProject(apiUrl);
+    const connectionId = typeof values['connection-id'] === 'string' ? values['connection-id'].trim() : '';
+    const repoSelector = typeof values.repo === 'string' ? values.repo.trim() : '';
+    const appName = (typeof values.name === 'string' && values.name.trim()) ||
+        positionals[0]?.trim() ||
+        '';
+    const slug = typeof values.slug === 'string' ? values.slug.trim() : undefined;
+    const rootDir = typeof values['root-dir'] === 'string' ? values['root-dir'] : undefined;
+    let githubConnectionId = connectionId;
+    let repo;
+    let branch = typeof values.branch === 'string' && values.branch.trim()
+        ? values.branch.trim()
+        : 'main';
+    if (!githubConnectionId) {
+        repo = await resolveGithubRepo(apiUrl, repoSelector || undefined);
+        branch =
+            typeof values.branch === 'string' && values.branch.trim()
+                ? values.branch.trim()
+                : repo.default_branch || 'main';
+        githubConnectionId = await ensureGithubConnection(apiUrl, ref, orgId, repo);
+    }
+    else if (repoSelector) {
+        throw new Error('Pass either --repo or --connection-id, not both.');
+    }
+    const resolvedName = appName || (repo ? defaultAppNameFromRepo(repo.name) : 'app');
+    const body = buildHostingAppCreateBody({
+        name: resolvedName,
+        slug,
+        github_connection_id: githubConnectionId,
+        branch,
+        root_dir: rootDir,
+    });
+    const slugCheck = await apiRequest(apiUrl, 'GET', `/platform/projects/${ref}/hosting/check-slug`, {
+        query: { slug: body.slug || resolvedName, name: body.name },
+    });
+    if (slugCheck.available === false) {
+        throw new Error(slugCheck.message || `Slug "${slugCheck.slug || body.slug}" is not available`);
+    }
+    const previewRepo = repo?.name || '(existing connection)';
+    const previewUrl = slugCheck.public_url || '';
+    if (input.isTTY && !values.yes) {
+        console.error([
+            `Create hosting app "${body.name}"`,
+            `Repo: ${previewRepo} @ ${branch}`,
+            previewUrl ? `URL:  ${previewUrl}` : '',
+            '',
+            'Proceed? [y/N]',
+        ]
+            .filter(Boolean)
+            .join('\n'));
+        const rl = createInterface({ input, output });
+        let answer = '';
+        try {
+            answer = (await rl.question('> ')).trim().toLowerCase();
+        }
+        finally {
+            rl.close();
+        }
+        if (answer !== 'y' && answer !== 'yes') {
+            console.error('Cancelled.');
+            return;
+        }
+    }
+    const created = await apiRequest(apiUrl, 'POST', `/platform/projects/${ref}/hosting/apps`, { json: body });
+    const app = created?.app;
+    if (!app?.id)
+        throw new Error('App creation failed (no app id).');
+    console.log(`Created app ${app.slug || app.name || app.id}`);
+    if (app.public_url)
+        console.log(app.public_url);
+    console.error(`Repo: ${previewRepo} @ ${branch}`);
+    if (values.deploy || values.wait) {
+        await deployHostingApp(apiUrl, ref, app, { wait: Boolean(values.wait) });
+    }
+    else {
+        console.error(`Deploy: zuvo hosting deploy --app ${app.slug || app.id} --wait`);
+    }
+}
 async function cmdHostingApps(apiUrl) {
     const ref = await requireLinkedRef();
     const apps = await listHostingApps(apiUrl, ref);
@@ -523,23 +729,8 @@ function assertHostingEnvKey(key) {
 async function getDeploymentStatus(apiUrl, ref, appId, deploymentId) {
     return apiRequest(apiUrl, 'GET', `/platform/projects/${ref}/hosting/apps/${appId}/deployments/${deploymentId}/logs`);
 }
-async function cmdHostingDeploy(apiUrl, argv) {
-    const { values } = parseArgs({
-        args: argv,
-        options: {
-            app: { type: 'string' },
-            commit: { type: 'string' },
-            wait: { type: 'boolean' },
-            '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 commitSha = typeof values.commit === 'string' && values.commit.trim()
-        ? values.commit.trim()
-        : undefined;
+async function deployHostingApp(apiUrl, ref, app, opts = {}) {
+    const commitSha = opts.commit?.trim() || undefined;
     const data = await apiRequest(apiUrl, 'POST', `/platform/projects/${ref}/hosting/apps/${app.id}/deploy`, {
         json: commitSha ? { commit_sha: commitSha } : {},
     });
@@ -547,7 +738,7 @@ async function cmdHostingDeploy(apiUrl, argv) {
     if (!deployment?.id)
         throw new Error('Deploy enqueue failed (no deployment id).');
     console.log(`Queued deploy ${deployment.id} for ${app.slug || app.id} (${deployment.status || 'queued'})`);
-    if (!values.wait) {
+    if (!opts.wait) {
         console.error(`Tip: zuvo hosting deploy-logs ${deployment.id} --app ${app.slug || app.id}`);
         return;
     }
@@ -580,6 +771,28 @@ async function cmdHostingDeploy(apiUrl, argv) {
         }
     }
 }
+async function cmdHostingDeploy(apiUrl, argv) {
+    const { values } = parseArgs({
+        args: argv,
+        options: {
+            app: { type: 'string' },
+            commit: { type: 'string' },
+            wait: { type: 'boolean' },
+            '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 commitSha = typeof values.commit === 'string' && values.commit.trim()
+        ? values.commit.trim()
+        : undefined;
+    await deployHostingApp(apiUrl, ref, app, {
+        commit: commitSha,
+        wait: Boolean(values.wait),
+    });
+}
 async function cmdHostingEnvList(apiUrl, argv) {
     const { values } = parseArgs({
         args: argv,
@@ -825,6 +1038,10 @@ async function main() {
             await cmdSecretsUnset(apiUrl, argvAfterCommand(argv, 'secrets', sub));
         else if (command === 'db' && sub === 'push')
             await cmdDbPush(apiUrl);
+        else if (command === 'github' && (sub === 'repos' || sub === 'list'))
+            await cmdGithubRepos(apiUrl, argvAfterCommand(argv, 'github', sub));
+        else if (command === 'hosting' && sub === 'create')
+            await cmdHostingCreate(apiUrl, argvAfterCommand(argv, 'hosting', 'create'));
         else if (command === 'hosting' && (sub === 'apps' || sub === 'list'))
             await cmdHostingApps(apiUrl);
         else if (command === 'hosting' && sub === 'deployments')

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zuvo/cli",
-  "version": "0.1.9",
+  "version": "0.1.11",
   "type": "module",
   "description": "Zuvo CLI — login, link, functions/hosting deploy, secrets, env, domains, db push, and logs",
   "license": "MIT",