@myapihq/cli 1.3.12 → 2.0.1

package/dist/commands/authproduct.js

@@ -0,0 +1,286 @@
+import { auth as sdkAuth } from '@myapihq/sdk';
+import { requireConfig } from '../config.js';
+import { success, error, info, printTable, printJson } from '../output.js';
+import { requireOrg } from '../helpers.js';
+// `myapi auth` — the END-USER auth product (my-auth-api): a managed OIDC IdP
+// for the users of apps built on MyAPI. Operator/account auth lives under
+// `myapi account` (see commands/auth.ts + index.ts dispatch). The machine
+// OIDC endpoints (discovery/jwks/authorize/token/userinfo) are consumed by
+// apps + the JS SDK, not the CLI, so only the management surface is here.
+export const SCHEMA = {
+    name: 'string',
+    type: 'string', // spa | web
+    redirect: 'string', // comma-separated redirect URIs
+    theme: 'string', // JSON for the hosted login page
+    connections: 'string', // comma-separated sign-in methods: google,password,magic
+    domain: 'string', // custom auth domain, e.g. auth.acme.com
+};
+export const EXPOSES = [
+    'POST /auth/orgs/{org_id}/tenant',
+    'GET /auth/orgs/{org_id}/tenant',
+    'POST /auth/orgs/{org_id}/clients',
+    'GET /auth/orgs/{org_id}/clients',
+    'GET /auth/orgs/{org_id}/usage',
+    'POST /auth/orgs/{org_id}/domain',
+    'GET /auth/orgs/{org_id}/domain',
+    'DELETE /auth/orgs/{org_id}/domain',
+];
+const SUBCOMMAND_USAGE = {
+    'tenant': `myapi auth tenant [show|create] [--connections <list>] [--theme <json>] [--org <id>] [--json]
+
+Your org's OIDC auth tenant — the identity provider your app's end users sign
+in against. One per org.
+
+  myapi auth tenant              Show the tenant (issuer + hosted login URL)
+  myapi auth tenant create       Create/enable it (idempotent)
+
+  --connections <list>  Sign-in methods on the hosted login page, comma-separated:
+                        google,password,magic (default: google).
+  --theme <json>        Branding JSON for the hosted login page.`,
+    'usage': `myapi auth usage [--org <id>] [--json]
+
+Monthly active users (MAU) for the current period — auth is billed per MAU.`,
+    'domain': `myapi auth domain [show|set|delete] [--domain <host>] [--org <id>] [--json]
+
+Serve auth on your own domain (e.g. auth.acme.com) instead of the default issuer.
+
+  myapi auth domain                         Show the current custom domain + status
+  myapi auth domain set --domain auth.acme.com   Register it (prints the DNS record to create)
+  myapi auth domain delete                  Remove the custom domain
+
+After 'set', create the printed DNS A record; TLS provisions automatically
+(~30 min) and the domain becomes your issuer once active.`,
+    'client': `myapi auth client <list|create> [--org <id>] [--json]
+
+OIDC clients are the apps that authenticate against your tenant.
+
+  myapi auth client list
+  myapi auth client create --name "My App" --type spa --redirect https://app.example.com/callback
+
+  --name <n>          Human label for the app (required)
+  --type spa|web      spa = public (no secret); web = confidential (secret once)
+  --redirect <urls>   Allowed redirect URIs, comma-separated (required).
+                      Absolute https (or http://localhost for dev).`,
+};
+export const HELP = `Usage: myapi auth <subcommand>
+
+Authentication for your app's end users — a managed OIDC identity provider
+(à la Kinde/Auth0). One auth tenant per org; register OIDC clients (apps)
+against it; sign users in via the hosted login page or the JS SDK; verify
+tokens locally against the tenant JWKS.
+
+End users sign in with managed Google, email/password, or magic links — pick
+which via \`tenant create --connections\`. (Operator/account commands moved to
+\`myapi account\`.)
+
+Subcommands:
+  client   Register and list OIDC clients (your apps)
+  domain   Serve auth on your own domain (auth.acme.com)
+  tenant   Show or create your org's OIDC auth tenant (+ sign-in methods)
+  usage    Monthly active users (MAU) for the current period`;
+export async function run(subcommand, args, flags) {
+    if (!subcommand || (flags.help && !subcommand)) {
+        info(HELP);
+        return;
+    }
+    if (flags.help) {
+        const usage = SUBCOMMAND_USAGE[subcommand];
+        info(usage ? `Usage: ${usage}` : `Unknown subcommand "${subcommand}". Run "myapi auth --help".`);
+        return;
+    }
+    switch (subcommand) {
+        case 'tenant': return tenant(args, flags);
+        case 'client': return client(args, flags);
+        case 'usage': return usage(flags);
+        case 'domain': return domain(args, flags);
+        default: error(`Unknown subcommand "${subcommand}". Run "myapi auth --help" for tenant/client/usage/domain.`);
+    }
+}
+async function tenant(args, flags) {
+    const action = args[0] || 'show';
+    const config = requireConfig();
+    const orgId = requireOrg(flags, config, 'myapi auth tenant [show|create] [--org <id>]');
+    if (action === 'show') {
+        try {
+            const t = await sdkAuth.getTenant(config.api_key, orgId);
+            if (flags.json) {
+                printJson(t);
+                return;
+            }
+            info(`Auth tenant: ${t.tenant_id}`);
+            info(`Issuer:    ${t.issuer}`);
+            info(`Login URL: ${t.login_url}`);
+            if (t.connections?.length)
+                info(`Sign-in:   ${t.connections.join(', ')}`);
+        }
+        catch (e) {
+            if (e?.code === 'TENANT_NOT_FOUND' || e?.status === 404) {
+                error('No auth tenant yet for this org.\nCreate it with: myapi auth tenant create');
+            }
+            throw e;
+        }
+        return;
+    }
+    if (action === 'create' || action === 'init') {
+        let theme;
+        if (flags.theme) {
+            try {
+                theme = JSON.parse(flags.theme);
+            }
+            catch {
+                error('--theme must be valid JSON');
+            }
+        }
+        let connections;
+        if (flags.connections) {
+            const allowed = ['google', 'password', 'magic'];
+            connections = flags.connections.split(',').map(s => s.trim()).filter(Boolean);
+            const bad = connections.filter(c => !allowed.includes(c));
+            if (bad.length)
+                error(`--connections may only contain google, password, magic (got: ${bad.join(', ')})`);
+        }
+        const t = await sdkAuth.createTenant(config.api_key, orgId, { theme, connections });
+        if (flags.json) {
+            printJson(t);
+            return;
+        }
+        success(`Auth tenant ready: ${t.tenant_id}`);
+        info(`Issuer:    ${t.issuer}`);
+        info(`Login URL: ${t.login_url}`);
+        if (t.connections?.length)
+            info(`Sign-in:   ${t.connections.join(', ')}`);
+        info('Next: register an app → myapi auth client create --name <n> --type spa --redirect <url>');
+        return;
+    }
+    error(`Unknown action "${action}". Use: myapi auth tenant [show|create]`);
+}
+async function usage(flags) {
+    const config = requireConfig();
+    const orgId = requireOrg(flags, config, 'myapi auth usage [--org <id>]');
+    const u = await sdkAuth.getUsage(config.api_key, orgId);
+    if (flags.json) {
+        printJson(u);
+        return;
+    }
+    info(`Period:       ${u.period}`);
+    info(`Active users: ${u.active_users} MAU`);
+    info(`Price:        $${(u.price_cents_each / 100).toFixed(2)} per MAU`);
+}
+async function domain(args, flags) {
+    const action = args[0] || 'show';
+    const config = requireConfig();
+    const orgId = requireOrg(flags, config, 'myapi auth domain [show|set|delete] [--org <id>]');
+    const showDomain = (d) => {
+        info(`Domain: ${d.domain}`);
+        info(`Status: ${d.status}`);
+        if (d.status !== 'active') {
+            info('');
+            info(`DNS — create this record:`);
+            info(`  ${d.dns.type}  ${d.dns.name}  →  ${d.dns.value}`);
+            if (d.next)
+                info(`\n${d.next}`);
+        }
+        else {
+            info(`Issuer:    ${d.issuer}`);
+            info(`Login URL: ${d.login_url}`);
+        }
+    };
+    if (action === 'show') {
+        try {
+            const d = await sdkAuth.getDomain(config.api_key, orgId);
+            if (flags.json) {
+                printJson(d);
+                return;
+            }
+            showDomain(d);
+        }
+        catch (e) {
+            if (e?.code === 'NO_DOMAIN' || e?.status === 404) {
+                error('No custom auth domain set.\nSet one with: myapi auth domain set --domain auth.example.com');
+            }
+            throw e;
+        }
+        return;
+    }
+    if (action === 'set' || action === 'register') {
+        const host = flags.domain || args[1] || '';
+        if (!host)
+            error('--domain is required (e.g. --domain auth.example.com)');
+        const d = await sdkAuth.registerDomain(config.api_key, orgId, host);
+        if (flags.json) {
+            printJson(d);
+            return;
+        }
+        success(`Custom auth domain registered: ${d.domain} (${d.status})`);
+        showDomain(d);
+        return;
+    }
+    if (action === 'delete' || action === 'remove') {
+        const host = flags.domain || args[1];
+        let target = host;
+        if (!target) {
+            // No host given — resolve the current one so the user doesn't have to retype it.
+            try {
+                target = (await sdkAuth.getDomain(config.api_key, orgId)).domain;
+            }
+            catch {
+                error('No custom auth domain to delete.');
+            }
+        }
+        await sdkAuth.deleteDomain(config.api_key, orgId, target);
+        success(`Custom auth domain removed: ${target}`);
+        return;
+    }
+    error(`Unknown action "${action}". Use: myapi auth domain [show|set|delete]`);
+}
+async function client(args, flags) {
+    const action = args[0] || 'list';
+    const config = requireConfig();
+    const orgId = requireOrg(flags, config, 'myapi auth client <list|create> [--org <id>]');
+    if (action === 'list') {
+        const res = await sdkAuth.listClients(config.api_key, orgId);
+        if (flags.json) {
+            printJson(res);
+            return;
+        }
+        printTable((res.clients || []).map(c => ({
+            ClientID: c.client_id,
+            Name: c.name || '',
+            Type: c.type,
+            Redirects: (c.redirect_uris || []).join(', '),
+        })), {
+            flags,
+            empty: 'No OIDC clients yet.\nCreate one: myapi auth client create --name <n> --type spa --redirect <url>',
+        });
+        return;
+    }
+    if (action === 'create') {
+        const name = flags.name || '';
+        const type = flags.type;
+        const redirect = flags.redirect || '';
+        if (!name)
+            error('--name is required (e.g. --name "My App")');
+        if (type !== 'spa' && type !== 'web')
+            error("--type must be 'spa' (public) or 'web' (confidential)");
+        if (!redirect)
+            error('--redirect is required (comma-separate multiple URIs)');
+        const redirect_uris = redirect.split(',').map(s => s.trim()).filter(Boolean);
+        const c = await sdkAuth.createClient(config.api_key, orgId, { name, type: type, redirect_uris });
+        if (flags.json) {
+            printJson(c);
+            return;
+        }
+        success(`Client created: ${c.client_id}`);
+        info(`Type:      ${c.type}`);
+        info(`Redirects: ${(c.redirect_uris || []).join(', ')}`);
+        if (c.issuer)
+            info(`Issuer:    ${c.issuer}`);
+        if (c.client_secret) {
+            info('');
+            info('Client secret (shown ONCE — store it now, it cannot be retrieved again):');
+            info(`  ${c.client_secret}`);
+        }
+        return;
+    }
+    error(`Unknown action "${action}". Use: myapi auth client <list|create>`);
+}

package/dist/commands/billing.js

@@ -92,7 +92,7 @@ export async function balance(flags) {
     // Anonymous accounts can't transact — paid surface is gated on a
     // verified email and credits only fund on upgrade. Surface the unblock.
     if (config.is_anonymous) {
-        info('→ Link an email to unlock $5 free credit + paid actions: myapi auth link <email>');
+        info('→ Link an email to unlock $5 free credit + paid actions: myapi account link <email>');
     }
 }
 export async function history(flags) {

package/dist/commands/config.js

@@ -49,7 +49,7 @@ export async function setFunnel(id, _flags, via = 'auth config') {
     const config = requireConfig();
     const orgId = config.default_org;
     if (!orgId)
-        error('No default organization set. Run: myapi auth config set-org <id>');
+        error('No default organization set. Run: myapi account config set-org <id>');
     info('› Validating…');
     const { funnel } = await sdkFunnel.getFunnel(config.api_key, orgId, id);
     const funnelId = funnel.id;

package/dist/commands/container.d.ts

@@ -11,6 +11,7 @@ export declare function create(flags: Flags): Promise<void>;
 export declare function list(flags: Flags): Promise<void>;
 export declare function get(id: string, flags: Flags): Promise<void>;
 export declare function del(id: string, flags: Flags): Promise<void>;
+export declare function _isTarball(p: string): boolean;
 export declare function deploy(id: string, image: string, flags: Flags): Promise<void>;
 export declare function logs(id: string, flags: Flags): Promise<void>;
 export declare function domain(id: string, domainArg: string | undefined, flags: Flags): Promise<void>;

package/dist/commands/container.js

@@ -1,7 +1,9 @@
+import { spawnSync } from 'node:child_process';
+import { readFile, stat } from 'node:fs/promises';
 import { container as sdkContainer } from '@myapihq/sdk';
 import { requireConfig } from '../config.js';
 import { success, error, printTable, info, printJson, banner } from '../output.js';
-import { formatDate } from '../utils.js';
+import { formatDate, pollJob } from '../utils.js';
 import { requireOrg } from '../helpers.js';
 export const EXPOSES = [
     'POST /container/orgs/{org_id}/containers',
@@ -25,6 +27,8 @@ export const SCHEMA = {
     env: 'string',
     tail: 'number',
     remove: 'boolean',
+    source: 'string',
+    image: 'string',
 };
 const CONTAINER_TYPES = ['service', 'worker', 'job'];
 // Mirrors validateName in myapi-hq/internal/routes/container/crud.go —
@@ -149,6 +153,8 @@ export async function get(id, flags) {
     if (c.port)
         info(`Port:            ${c.port}`);
     info(`URL:             ${c.url || '(not deployed)'}`);
+    if (c.egress)
+        info(`Egress:          ${c.egress}`);
     if (c.custom_domain)
         info(`Custom domain:   ${c.custom_domain}`);
     info(`Created:         ${c.created_at}`);
@@ -162,15 +168,106 @@ export async function del(id, flags) {
     await sdkContainer.deleteContainer(config.api_key, orgId, id);
     success(`Deleted container ${id}`);
 }
-// deploy ships a pre-built image to Cloud Run. The scoped API key is
-// rotated on every deploy — the fresh value is shown once here.
+// _isTarball returns true if the path looks like an already-built tar archive
+// (so we upload it as-is instead of tarring a directory).
+export function _isTarball(p) {
+    return /\.(tar|tar\.gz|tgz)$/i.test(p);
+}
+// tarDirectory builds a gzipped tarball of a build-context directory using the
+// system `tar`. Returns the archive bytes. We tar the directory contents (-C
+// <dir> .) so the Dockerfile sits at the root of the build context.
+async function tarDirectory(dir) {
+    const res = spawnSync('tar', ['-czf', '-', '-C', dir, '.'], {
+        maxBuffer: 200 * 1024 * 1024,
+    });
+    if (res.error) {
+        if (res.error.code === 'ENOENT') {
+            error('`tar` was not found on PATH. Install tar, or pass a pre-built .tar.gz to --source.');
+        }
+        error(`Failed to create build-context archive: ${res.error.message}`);
+    }
+    if (res.status !== 0) {
+        error(`tar exited ${res.status}: ${res.stderr?.toString().trim() || 'unknown error'}`);
+    }
+    return res.stdout;
+}
+// deploy ships either a pre-built image (--image / positional ref, synchronous)
+// or a source build context (--source <dir-or-tar>, asynchronous Cloud Build).
+// The scoped API key is rotated on every (image) deploy and shown once.
 export async function deploy(id, image, flags) {
     const config = requireConfig();
-    const orgId = requireOrg(flags, config, 'myapi container deploy <id> <image-ref> [--org <id>]');
+    const orgId = requireOrg(flags, config, 'myapi container deploy <id> <image-ref> | --source <dir|tar> [--org <id>]');
     if (!id)
-        error('Missing id.\nUsage: myapi container deploy <id> <image-ref>');
+        error('Missing id.\nUsage: myapi container deploy <id> <image-ref>   (or --source <dir|tar>)');
+    const source = typeof flags.source === 'string' ? flags.source : undefined;
+    // --image is an alias for the positional image ref.
+    if (!image && typeof flags.image === 'string')
+        image = flags.image;
+    if (source && image) {
+        error('Pass either an image ref or --source, not both.');
+    }
+    // ── Source-build path (async) ───────────────────────────────────────────
+    if (source) {
+        let tarball;
+        let filename = 'source.tar.gz';
+        let info_st;
+        try {
+            info_st = await stat(source);
+        }
+        catch (e) {
+            if (e?.code === 'ENOENT')
+                error(`Source not found: ${source}`);
+            error(`Could not read ${source}: ${e?.message ?? e}`);
+        }
+        if (info_st.isDirectory()) {
+            tarball = await tarDirectory(source);
+        }
+        else if (_isTarball(source)) {
+            tarball = await readFile(source);
+            filename = source.split('/').pop() || filename;
+        }
+        else {
+            error(`--source must be a directory or a .tar/.tar.gz/.tgz archive — got ${source}`);
+        }
+        const start = await sdkContainer.deployContainerSource(config.api_key, orgId, id, tarball, filename);
+        if (flags.json && start.status !== 'building') {
+            printJson(start);
+            return;
+        }
+        // Async: poll the container until it leaves the building state.
+        if (start.status === 'building') {
+            info(`Build started (revision ${start.revision_id}). Building from source via Cloud Build…`);
+            const final = await pollJob({
+                label: 'Building & deploying',
+                check: () => sdkContainer.getContainer(config.api_key, orgId, id),
+                isDone: (c) => c.status === 'active',
+                isFailed: (c) => c.status === 'build_error' || c.status === 'deploy_error',
+                failedMessage: 'Build/deploy failed — check `myapi container logs ' + id + '`.',
+                timeoutMs: 600_000,
+                intervalMs: 5_000,
+            });
+            if (flags.json) {
+                printJson(final);
+                return;
+            }
+            success(`Deployed container ${id} from source`);
+            info(`Status:          ${final.status}`);
+            info(`URL:             ${final.url || '(none — job container)'}`);
+            return;
+        }
+        // Backend deployed synchronously after all (unexpected for source) —
+        // surface whatever it returned.
+        if (flags.json) {
+            printJson(start);
+            return;
+        }
+        success(`Deployed container ${id} (revision ${start.revision_id})`);
+        info(`Status:          ${start.status}`);
+        return;
+    }
+    // ── Pre-built image path (sync) ─────────────────────────────────────────
     if (!image)
-        error('Missing image ref.\nUsage: myapi container deploy <id> <image-ref>\n\n→ <image-ref> is a pre-built container image (e.g. a registry path).');
+        error('Missing image ref.\nUsage: myapi container deploy <id> <image-ref>\n   or: myapi container deploy <id> --source <dir|tar>\n\n→ <image-ref> is a pre-built container image (e.g. a registry path).');
     const result = await sdkContainer.deployContainer(config.api_key, orgId, id, image);
     if (flags.json) {
         printJson(result);
@@ -247,12 +344,19 @@ Examples:
   myapi container create --name nightly --type job --cron "0 3 * * *"
   myapi container create --name queue-worker --type worker --memory 1Gi`,
     'deploy': `myapi container deploy <id> <image-ref> [--org <id>] [--json]
+       myapi container deploy <id> --source <dir|tar.gz> [--org <id>] [--json]
 
-Ships a pre-built container image to the runtime. The scoped API key is
-rotated on every deploy — the fresh value is printed once.
+Two ways to deploy:
+  image    Ship a pre-built image (positional ref or --image). Synchronous;
+           the scoped API key is rotated and printed once.
+  source   Upload a build context with --source <dir> (tarred locally) or a
+           pre-built --source <archive.tar.gz>. MyAPI builds it via Cloud
+           Build, then deploys. Asynchronous — the CLI polls until it's live.
 
-Example:
-  myapi container deploy <id> registry.example.com/my-app:v2`,
+Examples:
+  myapi container deploy <id> registry.example.com/my-app:v2
+  myapi container deploy <id> --source ./my-app
+  myapi container deploy <id> --source ./context.tar.gz`,
     'list': 'myapi container list [--org <id>] [--json]',
     'get': 'myapi container get <id> [--org <id>] [--json]',
     'logs': `myapi container logs <id> [--tail <n>] [--org <id>] [--json]
@@ -281,7 +385,7 @@ dependencies and long execution.
 Subcommands:
   create               Register a container and get its scoped API key (returned once)
   delete <id>          Soft-delete and revoke its scoped API key
-  deploy <id> <image>  Ship a pre-built image and go live
+  deploy <id> <image>  Ship a pre-built image (or --source <dir|tar> to build) and go live
   domain <id> <domain> Bind a custom domain (--remove to unbind)
   get <id>             Inspect a container
   list                 List containers in your org

package/dist/commands/domain.js

@@ -299,7 +299,7 @@ export async function emailSetup(domainArg, flags) {
         printJson(res);
         return;
     }
-    success(`Email infra provisioning on ${res.email_subdomain} (state: ${res.email_infra})`);
+    success(`Email infra provisioning on ${res.subdomain} (state: ${res.email_infra})`);
     if (res.next_step)
         info(res.next_step);
     info(`Track with: myapi domain status ${domain} --watch`);
@@ -533,7 +533,7 @@ Prerequisites:
   - WHOIS registrant info (ICANN requirement — see below)
 
 Registrant (required at every register call):
-  Cheapest path: run \`myapi auth registrant set\` once. The CLI stores
+  Cheapest path: run \`myapi account registrant set\` once. The CLI stores
   your name/email/phone/address and auto-injects it on every register.
 
   Per-call override (agent-friendly):

package/dist/commands/email/index.js

@@ -10,7 +10,6 @@ import * as mailbox from './mailbox.js';
 import * as message from './message.js';
 import * as warmup from './warmup.js';
 import * as template from './template.js';
-import * as campaign from './campaign.js';
 import * as verify from './verify.js';
 export const SCHEMA = {
     org: 'string',
@@ -53,15 +52,6 @@ const DEPRECATED_ALIASES = {
     'edit-template': ['template', 'edit'],
     'send-test': ['template', 'send-test'],
     'delete-template': ['template', 'delete'],
-    'create-campaign': ['campaign', 'create'],
-    'list-campaigns': ['campaign', 'list'],
-    'get-campaign': ['campaign', 'get'],
-    'update-campaign': ['campaign', 'update'],
-    'upload-contacts': ['campaign', 'upload-contacts'],
-    'start-campaign': ['campaign', 'start'],
-    'pause-campaign': ['campaign', 'pause'],
-    'resume-campaign': ['campaign', 'resume'],
-    'campaign-stats': ['campaign', 'stats'],
 };
 async function dispatchNamespace(ns, sub, restArgs, flags) {
     switch (ns) {
@@ -69,7 +59,6 @@ async function dispatchNamespace(ns, sub, restArgs, flags) {
         case 'message': return message.run(sub, restArgs, flags);
         case 'warmup': return warmup.run(sub, restArgs, flags);
         case 'template': return template.run(sub, restArgs, flags);
-        case 'campaign': return campaign.run(sub, restArgs, flags);
         case 'verify': return verify.run(sub, restArgs, flags);
         default: error(`Unknown namespace: ${ns}. Run "myapi email --help" for the list.`);
     }
@@ -79,7 +68,6 @@ export async function run(subcommand, args, flags) {
         info(`Usage: myapi email <namespace> <subcommand>
 
 Namespaces:
-  campaign   Email campaigns (org-scoped) — create, list, get, update, upload-contacts, start, pause, resume, stats
   mailbox    Mailboxes (account-scoped) — create, list, activate-sending
   message    Send & read mail (account-scoped) — send, status, sent, inbox, outbox, get
   template   Email templates (org-scoped) — generate, list, edit, send-test, delete
@@ -90,7 +78,6 @@ Examples:
   myapi email mailbox create hello@example.com
   myapi email message send --from a@x --to b@y --subject hi --body "hello"
   myapi email template generate welcome --prompt "Welcome email"
-  myapi email campaign create "Q2 Launch" --template-id <id> --from a@x
   myapi email verify alice@example.com
 
 Org-scoped commands accept --org <id> (or set default: myapi config set-org <id>).

package/dist/commands/fn.d.ts

@@ -11,6 +11,7 @@ export declare function list(flags: Flags): Promise<void>;
 export declare function get(id: string, flags: Flags): Promise<void>;
 export declare function del(id: string, flags: Flags): Promise<void>;
 export declare function deploy(id: string, bundlePath: string, flags: Flags): Promise<void>;
+export declare function _parseSetPairs(raw: string | string[]): Record<string, string> | string;
 export declare function setEnv(id: string, name: string, value: string, flags: Flags): Promise<void>;
 export declare function runs(id: string, flags: Flags): Promise<void>;
 export declare function run(subcommand: string | undefined, args: string[], flags: Flags): Promise<void>;