@myapihq/cli 1.2.4 → 1.2.6

package/dist/commands/billing.d.ts

@@ -8,3 +8,4 @@ export declare function balance(flags: Flags): Promise<void>;
 export declare function history(flags: Flags): Promise<void>;
 export declare function topup(amountStr: string, flags: Flags): Promise<void>;
 export declare function setup(_flags: Flags): Promise<void>;
+export declare function spendCap(arg: string | undefined, flags: Flags): Promise<void>;

package/dist/commands/billing.js

@@ -3,12 +3,16 @@ import { requireConfig } from '../config.js';
 import { success, error, printTable, info, printJson } from '../output.js';
 import { confirm, isNonInteractive } from '../prompt.js';
 import { formatDate } from '../utils.js';
-export const SCHEMA = {};
+export const SCHEMA = {
+    period: 'string', // spend-cap window: month | day
+};
 export const EXPOSES = [
     'GET /hq/billing/balance',
     'GET /hq/billing/history',
     'POST /hq/billing/setup-payment',
     'POST /hq/billing/topup',
+    'GET /hq/account/me',
+    'PATCH /hq/account/spend-cap',
 ];
 const SUBCOMMAND_USAGE = {
     'balance': 'myapi billing balance [--json]',
@@ -20,6 +24,18 @@ Confirmation is required for amounts of $50 or more — pass --yes to skip it.
 
 Example: myapi billing topup 10`,
     'setup': 'myapi billing setup',
+    'spend-cap': `myapi billing spend-cap [<amount> | clear] [--period month|day]
+
+The account-level spend ceiling (IAM "Layer 2") — a self-imposed limit
+*below* your balance that bounds total spend across every key and function.
+
+  myapi billing spend-cap              Show the current cap + period spend
+  myapi billing spend-cap 50           Cap total spend at $50/month
+  myapi billing spend-cap 5 --period day   Cap at $5/day
+  myapi billing spend-cap clear         Remove the cap
+
+This is distinct from a per-key cap (myapi keys create --spend-cap). The
+account cap is the aggregate backstop; per-key caps bound each credential.`,
 };
 export async function run(subcommand, args, flags) {
     if (!subcommand || (flags.help && !subcommand)) {
@@ -29,7 +45,8 @@ Subcommands:
   balance    Check balance, credits, and payment method status
   history    View recent transactions and top-ups
   topup      Top up your balance (whole dollars)
-  setup      Open a checkout link to add or update payment method`);
+  setup      Open a checkout link to add or update payment method
+  spend-cap  Set/show/clear the account-level spend ceiling (IAM Layer 2)`);
         return;
     }
     if (flags.help) {
@@ -45,6 +62,7 @@ Subcommands:
         case 'history': return history(flags);
         case 'topup': return topup(args[0], flags);
         case 'setup': return setup(flags);
+        case 'spend-cap': return spendCap(args[0], flags);
         default: error(`Unknown subcommand: ${subcommand}. Run "myapi billing --help" for available subcommands.`);
     }
 }
@@ -114,3 +132,44 @@ export async function setup(_flags) {
     const result = await hq.setupPayment(config.api_key);
     success(`Open this URL in your browser to set up payment:\n${result.url}`);
 }
+// The account-level spend ceiling. No arg → show; "clear" → remove; a
+// dollar amount → set. Distinct from per-key caps (myapi keys create
+// --spend-cap): this is the aggregate backstop across the whole account.
+export async function spendCap(arg, flags) {
+    const config = requireConfig();
+    if (!arg) {
+        const acct = await hq.getAccount(config.api_key);
+        if (flags.json) {
+            printJson({
+                spend_cap_cents: acct.spend_cap_cents ?? null,
+                current_period_spend_cents: acct.current_period_spend_cents ?? null,
+            });
+            return;
+        }
+        if (acct.spend_cap_cents == null) {
+            info('No account spend cap set.');
+            info('Set one with: myapi billing spend-cap <dollars> [--period month|day]');
+        }
+        else {
+            const spent = acct.current_period_spend_cents ?? 0;
+            info(`Account spend cap: $${(spent / 100).toFixed(2)} spent / $${(acct.spend_cap_cents / 100).toFixed(2)} this period`);
+        }
+        return;
+    }
+    if (arg === 'clear' || arg === 'none') {
+        await hq.setAccountSpendCap(config.api_key, null);
+        success('Account spend cap cleared.');
+        return;
+    }
+    const dollars = Number(arg);
+    if (!Number.isFinite(dollars) || dollars < 0) {
+        error(`Invalid amount "${arg}". Use a non-negative dollar amount, or "clear" to remove the cap.\nExample: myapi billing spend-cap 50`);
+    }
+    const period = flags.period || 'month';
+    if (period !== 'month' && period !== 'day') {
+        error(`Invalid --period "${period}". Use month or day.`);
+    }
+    const res = await hq.setAccountSpendCap(config.api_key, Math.round(dollars * 100), period);
+    const cents = res.spend_cap_cents ?? Math.round(dollars * 100);
+    success(`Account spend cap set: $${(cents / 100).toFixed(2)} per ${res.spend_cap_period}.`);
+}

package/dist/commands/domain.js

@@ -16,6 +16,11 @@ export const EXPOSES = [
     'GET /domain/orgs/{org_id}/{domain}/status',
     'POST /domain/orgs/{org_id}/{domain}/email-infra',
     'POST /domain/orgs/{org_id}/{domain}/retry-provisioning',
+    'GET /domain/orgs/{org_id}/{domain}/records',
+    'POST /domain/orgs/{org_id}/{domain}/records',
+    'GET /domain/orgs/{org_id}/{domain}/records/{record_id}',
+    'PATCH /domain/orgs/{org_id}/{domain}/records/{record_id}',
+    'DELETE /domain/orgs/{org_id}/{domain}/records/{record_id}',
 ];
 export const SCHEMA = {
     org: 'string',
@@ -50,6 +55,8 @@ export const SCHEMA = {
     yes: 'boolean',
     // Email-infra opt-in
     subdomain: 'string',
+    // Assign: opt out of binding the www Worker route alongside apex.
+    'no-www': 'boolean',
 };
 export async function check(domainArg, flags) {
     const config = requireConfig();
@@ -159,11 +166,20 @@ function summarizeDomain(d) {
 }
 export async function assign(domainArg, flags) {
     const config = requireConfig();
-    const orgId = requireOrg(flags, config, 'myapi domain assign <domain> [--org <id>]');
+    const orgId = requireOrg(flags, config, 'myapi domain assign <domain> [--no-www] [--org <id>]');
     if (!domainArg)
-        error('Missing required arguments.\nUsage: myapi domain assign <domain> [--org <id>]');
-    await sdkDomain.assignDomain(config.api_key, orgId, domainArg);
+        error('Missing required arguments.\nUsage: myapi domain assign <domain> [--no-www] [--org <id>]');
+    const includeWww = flags['no-www'] ? false : undefined; // omitted → backend default (true).
+    const res = await sdkDomain.assignDomain(config.api_key, orgId, domainArg, { includeWww });
+    if (flags.json) {
+        printJson(res);
+        return;
+    }
     success(`Assigned ${domainArg} to org ${orgId}`);
+    info(`  Worker routes bound: ${res.routes_bound.join('  and  ')}`);
+    if (res.include_www)
+        info(`  www.${domainArg} 301-redirects to https://${domainArg}/ (canonical apex)`);
+    info(`  Funnel will be live on https://${domainArg} once DNS propagates.`);
 }
 export async function unassign(domainArg, flags) {
     const config = requireConfig();
@@ -510,12 +526,20 @@ Charged against the org's billing balance — confirm with "myapi billing balanc
 before running.
 
 Track expiry afterward with: myapi domain status <domain>`,
-    'assign': `myapi domain assign <domain> [--org <id>]
+    'assign': `myapi domain assign <domain> [--no-www] [--org <id>]
+
+Assigns a registered or imported domain to an org. Backend binds Worker
+routes for both <domain>/* and www.<domain>/* by default; www returns a 301
+redirect to the apex (canonical URL). Once assigned, your funnel is served
+at https://<domain> after DNS propagation completes.
 
-Assigns a registered domain to an org. Once assigned, your funnel is served at
-https://<domain> after DNS propagation completes.
+  --no-www   Skip the www route binding. The www form will not resolve at the
+             edge unless you create your own DNS + Worker setup for it.
 
-To transfer to a different org: unassign first, then assign to the new org.`,
+WARNING: This is also the reassign path. If you previously assigned <domain>
+to a different org, re-running assign moves it. Pre-flight with:
+  myapi domain list --filter all
+to confirm the current binding before reassigning.`,
     'unassign': 'myapi domain unassign <domain> [--org <id>]',
     'status': `myapi domain status <domain> [--org <id>] [--watch] [--json]
 

package/dist/commands/fn-validation.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/commands/fn-validation.test.js

@@ -0,0 +1,60 @@
+// Unit tests for fn.ts CLI's pure name validator. Mirrors the regex +
+// reserved set in myapi-hq/internal/routes/function/crud.go so client-side
+// rejection matches server-side rejection.
+import { describe, it, expect } from 'vitest';
+import { _validateName, NAME_RE, RESERVED_NAMES } from './fn.js';
+describe('_validateName — pure helper', () => {
+    describe('valid names', () => {
+        it.each([
+            'a', // single char ok
+            'a1', // letters + digits
+            'my-app', // hyphen ok
+            'my-app-api',
+            '0', // digit-leading
+            '0app',
+            'abcdefghijabcdefghijabcdefghijabcdefghijabcdefghij', // 50 chars (max)
+            'fn-2026-05-15',
+        ])('accepts %s', (name) => {
+            expect(_validateName(name)).toBeNull();
+        });
+    });
+    describe('regex rejections', () => {
+        it.each([
+            ['empty string', ''],
+            ['UPPERCASE', 'BAD'],
+            ['mixed case', 'badName'],
+            ['underscore', 'my_app'],
+            ['leading hyphen', '-app'],
+            ['trailing hyphen ok but disallowed length too long', 'a'.repeat(51)],
+            ['spaces', 'my app'],
+            ['period', 'my.app'],
+            ['unicode', 'mōji'],
+            ['slash', 'a/b'],
+        ])('rejects %s (%s)', (_label, name) => {
+            expect(_validateName(name)).toMatch(/Invalid --name/);
+        });
+    });
+    describe('reserved names', () => {
+        it.each([...RESERVED_NAMES])('rejects reserved name %s', (name) => {
+            const err = _validateName(name);
+            expect(err).toMatch(/is reserved/);
+        });
+        it('regex check runs before reserved check (a value matching neither passes)', () => {
+            // 'ADMIN' fails the regex (uppercase) — not the reserved check.
+            expect(_validateName('ADMIN')).toMatch(/Invalid --name/);
+        });
+    });
+    describe('NAME_RE alignment with backend', () => {
+        it('matches the backend regex exactly: ^[a-z0-9][a-z0-9-]{0,49}$', () => {
+            // String equality on the source so any future drift surfaces here.
+            expect(NAME_RE.source).toBe('^[a-z0-9][a-z0-9-]{0,49}$');
+        });
+    });
+    describe('RESERVED_NAMES alignment with backend', () => {
+        it('matches the backend reservedNames map', () => {
+            // Sorted for stable comparison against the backend's list in
+            // myapi-hq/internal/routes/function/crud.go:21-28.
+            expect([...RESERVED_NAMES].sort()).toEqual(['admin', 'api', 'default', 'system', 'www']);
+        });
+    });
+});

package/dist/commands/fn.d.ts

@@ -0,0 +1,16 @@
+import type { FlagSchema } from '../flags.js';
+import { type Flags } from '../helpers.js';
+import type { Exposes } from '../exposes.js';
+export declare const EXPOSES: Exposes;
+export declare const SCHEMA: FlagSchema;
+export declare const NAME_RE: RegExp;
+export declare const RESERVED_NAMES: Set<string>;
+export declare function _validateName(name: string): string | null;
+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 deploy(id: string, bundlePath: string, flags: Flags): Promise<void>;
+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>;

package/dist/commands/fn.js

@@ -0,0 +1,271 @@
+import { readFile } from 'fs/promises';
+import { fn as sdkFn } from '@myapihq/sdk';
+import { requireConfig } from '../config.js';
+import { success, error, printTable, info, printJson, banner } from '../output.js';
+import { formatDate } from '../utils.js';
+import { requireOrg } from '../helpers.js';
+export const EXPOSES = [
+    'POST /function/orgs/{org_id}/functions',
+    'GET /function/orgs/{org_id}/functions',
+    'GET /function/orgs/{org_id}/functions/{id}',
+    'DELETE /function/orgs/{org_id}/functions/{id}',
+    'POST /function/orgs/{org_id}/functions/{id}/bundle',
+    'POST /function/orgs/{org_id}/functions/{id}/env',
+    'GET /function/orgs/{org_id}/functions/{id}/runs',
+];
+export const SCHEMA = {
+    cron: 'string',
+};
+// Backend: Story 1 (function CRUD + scoped key) and Story 2/4/5 (deploy a
+// JS bundle to Cloudflare Workers, list runs, set env secrets).
+// Mirrors validateName in myapi-hq/internal/routes/function/crud.go. We
+// pre-validate client-side so typos fail before the network call; backend
+// runs the same regex as defence in depth.
+//
+// Exported (alongside _validateNameOrThrow) so the unit test suite can hit
+// the regex and reserved list directly without spawning a subprocess.
+export const NAME_RE = /^[a-z0-9][a-z0-9-]{0,49}$/;
+export const RESERVED_NAMES = new Set(['www', 'api', 'admin', 'system', 'default']);
+// Returns an error message string on failure, or null on success. Pure —
+// no I/O, no process.exit. The caller in this file wraps it in `error()`
+// (which terminates); tests use the pure form.
+export function _validateName(name) {
+    if (!NAME_RE.test(name)) {
+        return `Invalid --name "${name}". Lowercase letters, digits, hyphens; 1-50 chars; starts with a letter or digit.`;
+    }
+    if (RESERVED_NAMES.has(name)) {
+        return `Name "${name}" is reserved. Pick a different one.`;
+    }
+    return null;
+}
+function validateName(name) {
+    const err = _validateName(name);
+    if (err)
+        error(err);
+}
+function summarizeFn(f) {
+    return {
+        id: f.id,
+        name: f.name,
+        trigger: f.trigger_type === 'cron' ? `cron ${f.cron_schedule ?? '?'}` : 'http',
+        url: f.invocation_url || '(not deployed)',
+        updated_at: f.updated_at,
+    };
+}
+export async function create(flags) {
+    const config = requireConfig();
+    const orgId = requireOrg(flags, config, 'myapi fn create --name <name> [--cron <expr>] [--org <id>]');
+    const name = flags.name;
+    if (!name) {
+        error('Missing --name.\nUsage: myapi fn create --name <name> [--cron <expr>] [--org <id>]\n\n→ Name is a kebab-case slug, 1-50 chars (e.g. "my-app-api").');
+    }
+    validateName(name);
+    const cron = flags.cron;
+    const payload = {
+        name,
+        trigger_type: cron ? 'cron' : 'http',
+    };
+    if (cron)
+        payload.cron_schedule = cron;
+    const result = await sdkFn.createFunction(config.api_key, orgId, payload);
+    success(`Function created: ${result.function.id}`);
+    info(`Name:            ${result.function.name}`);
+    info(`Trigger:         ${result.function.trigger_type}${result.function.cron_schedule ? ` (${result.function.cron_schedule})` : ''}`);
+    // The scoped key is returned ONCE — surface it prominently. It's used by
+    // the function runtime shim to call other slot endpoints without a
+    // baked-in auth token. Deploy rotates this key.
+    info('');
+    info(`Scoped API key (returned once — save it if you need it):`);
+    info(`  ${result.scoped_api_key}`);
+    info(`  (id: ${result.scoped_api_key_id}; scopes: slot_call; rejected at /hq/*, /admin/*, /internal/*)`);
+    if (!result.function.invocation_url) {
+        info('');
+        banner(`Next: deploy code with  myapi fn deploy ${result.function.id} <bundle.js>`);
+    }
+}
+export async function list(flags) {
+    const config = requireConfig();
+    const orgId = requireOrg(flags, config, 'myapi fn list [--org <id>]');
+    const fns = await sdkFn.listFunctions(config.api_key, orgId);
+    if (flags.json) {
+        printJson(fns);
+        return;
+    }
+    printTable(fns.map(summarizeFn), {
+        flags,
+        empty: 'No functions yet. Create one with: myapi fn create --name <name>',
+    });
+}
+export async function get(id, flags) {
+    const config = requireConfig();
+    const orgId = requireOrg(flags, config, 'myapi fn get <id> [--org <id>]');
+    if (!id)
+        error('Missing id.\nUsage: myapi fn get <id>');
+    const fn = await sdkFn.getFunction(config.api_key, orgId, id);
+    if (flags.json) {
+        printJson(fn);
+        return;
+    }
+    info(`ID:              ${fn.id}`);
+    info(`Name:            ${fn.name}`);
+    info(`Trigger:         ${fn.trigger_type}${fn.cron_schedule ? ` (${fn.cron_schedule})` : ''}`);
+    info(`Invocation URL:  ${fn.invocation_url || '(not deployed)'}`);
+    info(`Created:         ${fn.created_at}`);
+    info(`Updated:         ${fn.updated_at}`);
+}
+export async function del(id, flags) {
+    const config = requireConfig();
+    const orgId = requireOrg(flags, config, 'myapi fn delete <id> [--org <id>]');
+    if (!id)
+        error('Missing id.\nUsage: myapi fn delete <id>');
+    await sdkFn.deleteFunction(config.api_key, orgId, id);
+    success(`Deleted function ${id}`);
+}
+// deploy uploads a single-file JS bundle. The backend wraps it with the
+// MYAPI shim and ships it to Cloudflare Workers. The scoped API key is
+// rotated on every deploy — the fresh value is shown once here.
+export async function deploy(id, bundlePath, flags) {
+    const config = requireConfig();
+    const orgId = requireOrg(flags, config, 'myapi fn deploy <id> <bundle.js> [--org <id>]');
+    if (!id)
+        error('Missing id.\nUsage: myapi fn deploy <id> <bundle.js>');
+    if (!bundlePath)
+        error('Missing bundle file.\nUsage: myapi fn deploy <id> <bundle.js>\n\n→ <bundle.js> is a single-file JavaScript bundle (≤4MB).');
+    let data;
+    try {
+        data = await readFile(bundlePath);
+    }
+    catch (e) {
+        if (e?.code === 'ENOENT')
+            error(`File not found: ${bundlePath}`);
+        if (e?.code === 'EACCES')
+            error(`Permission denied: ${bundlePath}`);
+        error(`Could not read ${bundlePath}: ${e?.message ?? e}`);
+    }
+    const result = await sdkFn.uploadBundle(config.api_key, orgId, id, data, bundlePath.split('/').pop() || 'bundle.js');
+    if (flags.json) {
+        printJson(result);
+        return;
+    }
+    success(`Deployed function ${id}`);
+    info(`Invocation URL:  ${result.invocation_url}`);
+    info('');
+    info(`Scoped API key was rotated. New value (returned once — save it if you need it):`);
+    info(`  ${result.scoped_api_key}`);
+}
+// env sets a Worker Secret (Stripe key, etc.) on a deployed function.
+export async function setEnv(id, name, value, flags) {
+    const config = requireConfig();
+    const orgId = requireOrg(flags, config, 'myapi fn env <id> <name> <value> [--org <id>]');
+    if (!id)
+        error('Missing id.\nUsage: myapi fn env <id> <name> <value>');
+    if (!name)
+        error('Missing secret name.\nUsage: myapi fn env <id> <name> <value>');
+    if (value === undefined)
+        error('Missing secret value.\nUsage: myapi fn env <id> <name> <value>');
+    await sdkFn.setFunctionEnv(config.api_key, orgId, id, name, value);
+    success(`Set ${name} on function ${id}`);
+    info('The value is encrypted at rest by Cloudflare and never stored or echoed by MyAPI.');
+}
+// runs lists recent invocation records, most recent first.
+export async function runs(id, flags) {
+    const config = requireConfig();
+    const orgId = requireOrg(flags, config, 'myapi fn runs <id> [--org <id>]');
+    if (!id)
+        error('Missing id.\nUsage: myapi fn runs <id>');
+    const records = await sdkFn.listFunctionRuns(config.api_key, orgId, id);
+    if (flags.json) {
+        printJson(records);
+        return;
+    }
+    printTable(records.map(r => ({
+        id: r.id,
+        invoked_at: formatDate(r.invoked_at),
+        status: r.status || '?',
+        duration_ms: r.duration_ms ?? '',
+        error: r.error_message || '',
+    })), {
+        flags,
+        empty: 'No runs recorded yet for this function.',
+    });
+}
+// ── Dispatcher ───────────────────────────────────────────────────────────────
+const SUBCOMMAND_USAGE = {
+    'create': `myapi fn create --name <name> [--cron <expr>] [--org <id>]
+
+Persists a function record + issues a scoped API key. Deploy code separately
+with "myapi fn deploy".
+
+Triggers:
+  (default)         HTTP — function gets a public invocation URL once deployed.
+  --cron <expr>     Cron — function runs on the schedule (e.g. "0 8 * * *").
+
+Examples:
+  myapi fn create --name my-app-api
+  myapi fn create --name daily-report --cron "0 8 * * *"
+
+The response returns the scoped API key ONCE. It lets the function call
+other MyAPI slots with its own permissions (scopes=slot_call; rejected at
+/hq/*, /admin/*, /internal/*).`,
+    'deploy': `myapi fn deploy <id> <bundle.js> [--org <id>] [--json]
+
+Uploads a single-file JavaScript bundle (≤4MB) to the edge runtime. The
+backend wraps it with the MYAPI shim and ships it to Cloudflare Workers.
+
+The scoped API key is rotated on every deploy — the fresh value is printed
+once. After deploy the function has a live invocation URL.
+
+Example:
+  myapi fn deploy <id> ./dist/bundle.js`,
+    'env': `myapi fn env <id> <name> <value> [--org <id>]
+
+Sets a secret (Stripe key, API token, ...) as a Cloudflare Worker Secret on
+a deployed function. The value is encrypted at rest and never stored in
+MyAPI or echoed back. The function must already be deployed.
+
+Example:
+  myapi fn env <id> STRIPE_KEY sk_live_...`,
+    'runs': `myapi fn runs <id> [--org <id>] [--json]
+
+Lists recent invocation records (most recent first, up to 100).`,
+    'list': 'myapi fn list [--org <id>] [--json]',
+    'get': 'myapi fn get <id> [--org <id>] [--json]',
+    'delete': 'myapi fn delete <id> [--org <id>]',
+};
+export async function run(subcommand, args, flags) {
+    if (!subcommand || (flags.help && !subcommand)) {
+        info(`Usage: myapi fn <subcommand>
+
+Create, deploy, and manage functions on the MyAPI edge runtime.
+
+Subcommands:
+  create               Register a function and get its scoped API key (returned once)
+  deploy <id> <file>   Upload a JS bundle and go live
+  env <id> <k> <v>     Set a Worker Secret on a deployed function
+  runs <id>            List recent invocation records
+  list                 List functions in your org
+  get <id>             Inspect a function
+  delete <id>          Soft-delete and revoke its scoped API key
+
+All commands accept --org <id> (or set default: myapi config set-org <id>).`);
+        return;
+    }
+    if (flags.help) {
+        const usage = SUBCOMMAND_USAGE[subcommand];
+        if (usage)
+            info(`Usage: ${usage}`);
+        else
+            info(`Unknown subcommand: ${subcommand}. Run "myapi fn --help" for the list.`);
+        return;
+    }
+    switch (subcommand) {
+        case 'create': return create(flags);
+        case 'deploy': return deploy(args[0], args[1], flags);
+        case 'env': return setEnv(args[0], args[1], args[2], flags);
+        case 'runs': return runs(args[0], flags);
+        case 'list': return list(flags);
+        case 'get': return get(args[0], flags);
+        case 'delete': return del(args[0], flags);
+        default: error(`Unknown subcommand: ${subcommand}. Run "myapi fn --help" for a list of valid subcommands.`);
+    }
+}

package/dist/commands/funnel.d.ts

@@ -10,4 +10,5 @@ export declare function del(id: string, flags: Flags): Promise<void>;
 export declare function pages(funnelArg: string, flags: Flags): Promise<void>;
 export declare function push(slug: string, flags: Flags): Promise<void>;
 export declare function verify(slug: string, flags: Flags): Promise<void>;
+export declare function publish(dir: string, flags: Flags): Promise<void>;
 export declare function run(subcommand: string | undefined, args: string[], flags: Flags): Promise<void>;