@myapihq/cli 2.3.1 → 2.4.0

package/dist/commands/account.d.ts

@@ -3,7 +3,7 @@ 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 HELP = "Usage: myapi account <subcommand>\n\nSubcommands:\n  api-keys        Manage API keys \u00B7 list / create / revoke\n  config          Manage CLI defaults (org, funnel, domain) \u00B7 supports set-org / set-funnel / set-domain\n  import-key      Import an existing API key non-interactively\n  install-skills  DEPRECATED \u2014 use `myapi install-skills` instead\n  keys            Alias for api-keys\n  link [email]    Upgrade anonymous account to registered (or add a second session)\n                  Use myapi account setup to create a completely new account\n  mailing-address Get or set the account's mailing address (CAN-SPAM)\n  registrant      Manage stored WHOIS contact info for domain registration \u00B7 set / get / clear\n  setup           Configure your account\n  switch [index]  Switch active account by index or email\n  whoami          Show current account \u00B7 supports --json";
+export declare const HELP = "Usage: myapi account <subcommand>\n\nSubcommands:\n  api-keys        Manage API keys \u00B7 list / create / revoke\n  config          Manage CLI defaults (org, funnel, domain) \u00B7 supports set-org / set-funnel / set-domain\n  import-key      Import an existing API key non-interactively\n  install-skills  DEPRECATED \u2014 use `myapi install-skills` instead\n  keys            Alias for api-keys\n  link [email]    Upgrade anonymous account to registered (or add a second session)\n                  Use myapi account setup to create a completely new account\n  login           Sign in via your browser \u2014 Google or email code (preview: --mock)\n  mailing-address Get or set the account's mailing address (CAN-SPAM)\n  registrant      Manage stored WHOIS contact info for domain registration \u00B7 set / get / clear\n  setup           Configure your account\n  switch [index]  Switch active account by index or email\n  whoami          Show current account \u00B7 supports --json";
 export declare const INSTALL_SKILLS_HELP = "Usage: myapi install-skills\n\nInstalls the MyAPI skills pack for AI coding agents (Claude, Codex, Gemini, \u2026).\n\nThis command writes skill definition files to:\n  ~/.agents/skills/myapi/\n\nAnd creates symlinks in the appropriate agent config directories:\n  ~/.claude/  (Claude)\n  ~/.gemini/  (Gemini)\n  ~/.cursor/  (Cursor, if detected)\n\nThese files teach agents how to use the MyAPI CLI and API directly.\nRun this command again to update existing skills to the latest version.\n\nNote: `myapi account install-skills` is deprecated and will be removed in the next minor.\nUse `myapi install-skills` going forward.";
 export declare function link(flags?: Flags, emailArg?: string): Promise<void>;
 export declare function whoami(flags?: Flags): Promise<void>;

package/dist/commands/account.js

@@ -36,6 +36,7 @@ Subcommands:
   keys            Alias for api-keys
   link [email]    Upgrade anonymous account to registered (or add a second session)
                   Use myapi account setup to create a completely new account
+  login           Sign in via your browser — Google or email code (preview: --mock)
   mailing-address Get or set the account's mailing address (CAN-SPAM)
   registrant      Manage stored WHOIS contact info for domain registration · set / get / clear
   setup           Configure your account

package/dist/commands/authproduct.js

@@ -1,4 +1,4 @@
-import { auth as sdkAuth } from '@myapihq/sdk';
+import { auth as sdkAuth, MyApiError } from '@myapihq/sdk';
 import { requireConfig } from '../config.js';
 import { confirm, isNonInteractive } from '../prompt.js';
 import { success, error, info, printTable, printJson } from '../output.js';
@@ -270,11 +270,15 @@ async function domain(args, flags) {
         let target = host;
         if (!target) {
             // No host given — resolve the current one so the user doesn't have to retype it.
+            // Only a 404 means "nothing configured"; a network/auth/server error must
+            // surface as itself, not be misreported as absent state.
             try {
                 target = (await sdkAuth.getDomain(config.api_key, orgId)).domain;
             }
-            catch {
-                error('No custom auth domain to delete.');
+            catch (e) {
+                if (e instanceof MyApiError && e.status === 404)
+                    error('No custom auth domain to delete.');
+                throw e;
             }
         }
         await sdkAuth.deleteDomain(config.api_key, orgId, target);

package/dist/commands/billing.js

@@ -162,8 +162,13 @@ export async function usage(flags) {
     info(`Total: ${res.total_display}`);
 }
 export async function topup(amountStr, flags) {
-    const amount = Math.round(parseFloat(amountStr));
-    if (!amountStr || isNaN(amount) || amount <= 0) {
+    // Money-moving input is validated strictly: whole dollars only, no
+    // trailing garbage, no silent rounding ("10.9" must not charge $11).
+    if (!amountStr || !/^\d+$/.test(amountStr)) {
+        error('Amount must be a positive whole number of dollars (e.g. myapi billing topup 10)');
+    }
+    const amount = Number(amountStr);
+    if (amount <= 0) {
         error('Amount must be a positive whole number of dollars (e.g. myapi billing topup 10)');
     }
     if (!flags.yes && !flags.y && amount >= 50) {

package/dist/commands/container.js

@@ -4,7 +4,7 @@ import { container as sdkContainer } from '@myapihq/sdk';
 import { requireConfig } from '../config.js';
 import { success, error, printTable, info, printJson, banner } from '../output.js';
 import { formatDate, pollJob } from '../utils.js';
-import { requireOrg } from '../helpers.js';
+import { requireOrg, confirmDestructive } from '../helpers.js';
 export const EXPOSES = [
     'POST /container/orgs/{org_id}/containers',
     'GET /container/orgs/{org_id}/containers',
@@ -162,11 +162,12 @@ export async function get(id, flags) {
 }
 export async function del(id, flags) {
     const config = requireConfig();
-    const orgId = requireOrg(flags, config, 'myapi container delete <id> [--org <id>]');
+    const orgId = requireOrg(flags, config, 'myapi container delete <id> [--yes] [--org <id>]');
     if (!id)
         error('Missing id.\nUsage: myapi container delete <id>');
+    await confirmDestructive(flags, `delete container ${id} in org ${orgId}`, 'myapi container delete <id> --yes [--org <id>]');
     await sdkContainer.deleteContainer(config.api_key, orgId, id);
-    success(`Deleted container ${id}`);
+    success(`Deleted container ${id} (org ${orgId})`);
 }
 // _isTarball returns true if the path looks like an already-built tar archive
 // (so we upload it as-is instead of tarring a directory).

package/dist/commands/database.js

@@ -7,7 +7,7 @@ import * as fs from 'fs';
 import { database as sdk, MyApiError } from '@myapihq/sdk';
 import { requireConfig } from '../config.js';
 import { success, error, info, printTable, printJson } from '../output.js';
-import { requireOrg, requireArg } from '../helpers.js';
+import { requireOrg, requireArg, confirmDestructive } from '../helpers.js';
 export const EXPOSES = [
     'GET /database/orgs/{org_id}/namespaces',
     'POST /database/orgs/{org_id}/namespaces',
@@ -97,10 +97,11 @@ async function nsCreate(name, flags) {
 }
 async function nsDelete(name, flags) {
     const config = requireConfig();
-    const orgId = requireOrg(flags, config, 'myapi database delete-namespace <name> [--org <id>]');
+    const orgId = requireOrg(flags, config, 'myapi database delete-namespace <name> [--yes] [--org <id>]');
     requireArg(name, 'name', 'myapi database delete-namespace <name>');
+    await confirmDestructive(flags, `delete namespace "${name}" and ALL its keys in org ${orgId}`, 'myapi database delete-namespace <name> --yes [--org <id>]');
     await sdk.deleteNamespace(config.api_key, orgId, name);
-    success(`Namespace "${name}" and all its keys deleted.`);
+    success(`Namespace "${name}" and all its keys deleted (org ${orgId}).`);
 }
 // ── Keys ─────────────────────────────────────────────────────────────────
 async function keysList(flags) {

package/dist/commands/domain.js

@@ -1,8 +1,9 @@
 import { domain as sdkDomain, email as sdkEmail } from '@myapihq/sdk';
 import { requireConfig } from '../config.js';
 import { success, error, info, printTable, printJson } from '../output.js';
-import { formatDate } from '../utils.js';
+import { formatDate, retryFunds } from '../utils.js';
 import { resolveRegistrantForRegister } from '../registrant.js';
+import { confirm, isNonInteractive } from '../prompt.js';
 import { requireOrg, requireDomain } from '../helpers.js';
 export const EXPOSES = [
     'GET /domain/orgs/{org_id}/list',
@@ -63,6 +64,8 @@ export const SCHEMA = {
     subdomain: 'string',
     // Assign: opt out of binding the www Worker route alongside apex.
     'no-www': 'boolean',
+    // Assign: override the reassignment pre-flight guard.
+    force: 'boolean',
 };
 export async function check(domainArg, flags) {
     const config = requireConfig();
@@ -97,7 +100,7 @@ export async function register(domainArg, flags) {
     // Required by ICANN; resolver throws a useful error if nothing's set up
     // in non-interactive contexts, or runs an interactive prompt for humans.
     const registrant = await resolveRegistrantForRegister(flags, config);
-    await sdkDomain.registerDomain(config.api_key, orgId, domainArg, { years, registrant });
+    await retryFunds(() => sdkDomain.registerDomain(config.api_key, orgId, domainArg, { years, registrant }));
     success(`Registered ${domainArg}!`);
     info(`Assign it to your org now:\n  myapi domain assign ${domainArg} --org ${orgId}`);
     info(`DNS propagation can take a few minutes — track it with: myapi domain status ${domainArg}`);
@@ -166,7 +169,15 @@ export async function renew(domainArg, flags) {
     const orgId = requireOrg(flags, config, 'myapi domain renew <domain> [--yes] [--org <id>]');
     if (!domainArg)
         error('Missing required arguments.\nUsage: myapi domain renew <domain> [--yes] [--org <id>]');
-    await sdkDomain.renewDomain(config.api_key, orgId, domainArg);
+    if (!flags.yes) {
+        if (isNonInteractive()) {
+            error(`Refusing to renew ${domainArg} without --yes — renewal charges org ${orgId}'s balance immediately.\nUsage: myapi domain renew <domain> --yes [--org <id>]`);
+        }
+        const ok = await confirm(`› Renew ${domainArg} now? This charges org ${orgId}'s balance. (y/N) `, false);
+        if (!ok)
+            error('Aborted.');
+    }
+    await retryFunds(() => sdkDomain.renewDomain(config.api_key, orgId, domainArg));
     success(`Renewed ${domainArg}.`);
     info(`Track expiry with: myapi domain status ${domainArg}`);
 }
@@ -196,6 +207,23 @@ export async function assign(domainArg, flags) {
     const orgId = requireOrg(flags, config, 'myapi domain assign <domain> [--no-www] [--org <id>]');
     if (!domainArg)
         error('Missing required arguments.\nUsage: myapi domain assign <domain> [--no-www] [--org <id>]');
+    // Assign is also the reassign path: if the domain is currently bound to a
+    // *different* org, a bare assign silently moves it (this has bitten us in
+    // production). Pre-flight the current binding and require --force to move.
+    // A failed pre-read aborts — never downgrade a safety check to a guess.
+    if (!flags.force) {
+        let current;
+        try {
+            const domains = await sdkDomain.listDomains(config.api_key, orgId, 'all');
+            current = domains.find(d => d.domain === domainArg);
+        }
+        catch (e) {
+            error(`Could not verify ${domainArg}'s current assignment (${e instanceof Error ? e.message : e}).\nRefusing to assign blind — retry, or pass --force to skip this check.`);
+        }
+        if (current?.org_id && current.org_id !== orgId) {
+            error(`${domainArg} is currently assigned to org ${current.org_id}.\nAssigning it to org ${orgId} would MOVE it. Re-run with --force to reassign.`);
+        }
+    }
     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) {
@@ -398,10 +426,6 @@ async function recordsGet(domainArg, recordId, flags) {
     if (!recordId)
         error('Missing record id.\nUsage: myapi domain records get <domain> <record-id>');
     const r = await sdkDomain.getDnsRecord(config.api_key, orgId, domain, recordId);
-    if (flags.json) {
-        printJson(r);
-        return;
-    }
     printJson(r);
 }
 async function recordsCreate(domainArg, flags) {
@@ -564,14 +588,15 @@ After running:
   2. At your current registrar, change the nameservers to the values returned.
   3. Wait for propagation. Use "myapi domain status <domain> --watch" to track
      activation — the backend live-checks Cloudflare each time you poll.`,
-    'renew': `myapi domain renew <domain> [--org <id>]
+    'renew': `myapi domain renew <domain> [--yes] [--org <id>]
 
 Renews a registered domain for one more registration period (typically 1 year).
 Charged against the org's billing balance — confirm with "myapi billing balance"
-before running.
+before running. Asks for confirmation; pass --yes to skip (required in
+non-interactive runs).
 
 Track expiry afterward with: myapi domain status <domain>`,
-    'assign': `myapi domain assign <domain> [--no-www] [--org <id>]
+    'assign': `myapi domain assign <domain> [--no-www] [--force] [--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
@@ -580,11 +605,11 @@ 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.
+  --force    Skip the reassignment pre-flight guard.
 
-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.`,
+WARNING: This is also the reassign path. If the domain is currently assigned
+to a different org, assign refuses unless you pass --force. Check the current
+binding with: myapi domain list --filter all`,
     'unassign': 'myapi domain unassign <domain> [--org <id>]',
     'status': `myapi domain status <domain> [--org <id>] [--watch] [--json]
 

package/dist/commands/email/message.js

@@ -1,6 +1,7 @@
 import { email as sdkEmail } from '@myapihq/sdk';
 import { requireConfig } from '../../config.js';
 import { success, error, printTable, printJson, info } from '../../output.js';
+import { retryFunds } from '../../utils.js';
 export const EXPOSES = [
     'POST /email/send',
     'GET /email/status/{message_id}',
@@ -22,7 +23,9 @@ function summarizeMessage(m) {
 }
 async function send(flags) {
     const config = requireConfig();
-    if (!flags.from || !flags.to || !flags.subject) {
+    // typeof check (not truthiness): a bare `--to` whose value got swallowed by
+    // the next flag parses as `true`, which must fail here — not reach the API.
+    if (typeof flags.from !== 'string' || typeof flags.to !== 'string' || typeof flags.subject !== 'string') {
         error('Missing required arguments.\nUsage: myapi email message send --from <email> --to <email> --subject <str> [--body <str> | --html <str> | --template-id <id> [--template-vars <json>]]');
     }
     if (!flags.body && !flags.html && !flags['template-id'])
@@ -38,7 +41,7 @@ async function send(flags) {
             error('--template-vars must be valid JSON');
         }
     }
-    const res = await sdkEmail.sendEmail(config.api_key, {
+    const res = await retryFunds(() => sdkEmail.sendEmail(config.api_key, {
         from: flags.from,
         to: [flags.to],
         subject: flags.subject,
@@ -46,7 +49,7 @@ async function send(flags) {
         html: flags.html,
         template_id: flags['template-id'],
         template_vars: templateVars,
-    });
+    }));
     success(`Email sent! Message ID: ${res.message_id}`);
 }
 async function status(messageId, _flags) {

package/dist/commands/email/template.js

@@ -1,7 +1,7 @@
 import { email as sdkEmail } from '@myapihq/sdk';
 import { requireConfig } from '../../config.js';
 import { success, error, printTable, printJson, info } from '../../output.js';
-import { pollJob } from '../../utils.js';
+import { pollJob, retryFunds } from '../../utils.js';
 import { requireOrg } from '../../helpers.js';
 export const EXPOSES = [
     'POST /email/orgs/{org_id}/templates/generate',
@@ -20,10 +20,10 @@ async function generate(nameArg, flags) {
     if (!name || !flags.prompt) {
         error('Missing required arguments.\nUsage: myapi email template generate <name> --prompt <str> [--org <id>]\n   or: myapi email template generate --name <name> --prompt <str> [--org <id>]');
     }
-    const job = await sdkEmail.generateTemplate(config.api_key, orgId, {
+    const job = await retryFunds(() => sdkEmail.generateTemplate(config.api_key, orgId, {
         prompt: flags.prompt,
         name,
-    });
+    }));
     const status = await pollJob({
         label: 'Generating template',
         timeoutMs: 90_000,

package/dist/commands/fn.js

@@ -3,7 +3,7 @@ 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';
+import { requireOrg, confirmDestructive } from '../helpers.js';
 export const EXPOSES = [
     'POST /function/orgs/{org_id}/functions',
     'GET /function/orgs/{org_id}/functions',
@@ -126,11 +126,12 @@ export async function get(id, flags) {
 }
 export async function del(id, flags) {
     const config = requireConfig();
-    const orgId = requireOrg(flags, config, 'myapi fn delete <id> [--org <id>]');
+    const orgId = requireOrg(flags, config, 'myapi fn delete <id> [--yes] [--org <id>]');
     if (!id)
         error('Missing id.\nUsage: myapi fn delete <id>');
+    await confirmDestructive(flags, `delete function ${id} in org ${orgId}`, 'myapi fn delete <id> --yes [--org <id>]');
     await sdkFn.deleteFunction(config.api_key, orgId, id);
-    success(`Deleted function ${id}`);
+    success(`Deleted function ${id} (org ${orgId})`);
 }
 // 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

package/dist/commands/funnel.js

@@ -4,7 +4,7 @@ import { funnel as sdkFunnel, hq } from '@myapihq/sdk';
 import { requireConfig } from '../config.js';
 import { success, error, printTable, info, printJson } from '../output.js';
 import { formatDate } from '../utils.js';
-import { requireOrg } from '../helpers.js';
+import { requireOrg, confirmDestructive } from '../helpers.js';
 export const EXPOSES = [
     'POST /funnel/orgs/{org_id}/funnels',
     'GET /funnel/orgs/{org_id}/funnels',
@@ -77,7 +77,7 @@ export async function list(flags) {
     }
     const rows = funnels.map(f => ({
         id: f.id,
-        preview_url: f.subdomain_url || '',
+        subdomain_url: f.subdomain_url || '',
         created_at: formatDate(f.created_at),
         updated_at: formatDate(f.updated_at),
     }));
@@ -128,11 +128,12 @@ export async function get(id, flags) {
 }
 export async function del(id, flags) {
     const config = requireConfig();
-    const orgId = requireOrg(flags, config, 'myapi funnel delete <id> [--org <id>]');
+    const orgId = requireOrg(flags, config, 'myapi funnel delete <id> [--yes] [--org <id>]');
     if (!id)
-        error('Missing required arguments.\nUsage: myapi funnel delete <id> [--org <id>]');
+        error('Missing required arguments.\nUsage: myapi funnel delete <id> [--yes] [--org <id>]');
+    await confirmDestructive(flags, `delete funnel ${id} (and all its live pages) in org ${orgId}`, 'myapi funnel delete <id> --yes [--org <id>]');
     await sdkFunnel.deleteFunnel(config.api_key, orgId, id);
-    success(`Funnel ${id} deleted`);
+    success(`Funnel ${id} deleted (org ${orgId})`);
 }
 // List the pages currently published to a funnel. Resolves the funnel id
 // from positional arg, --funnel flag, or the user's default funnel.
@@ -206,19 +207,34 @@ This funnel already serves a page at ${finalSlug}; pushing would replace it.
         error("No content provided via stdin. Usage: echo '<h1>Hello</h1>' | myapi funnel push [slug]");
     const result = await sdkFunnel.pushFunnelPage(config.api_key, orgId, funnelId, { slug: finalSlug, html });
     const { orgLabel, funnelLabel } = await describeTarget(config.api_key, orgId, funnelId);
+    let liveUrl = result?.url;
+    if (!liveUrl) {
+        // Best-effort URL enrichment — the push already succeeded, so a failed
+        // org lookup must not turn a successful write into a non-zero exit.
+        const org = await hq.getOrg(config.api_key, orgId).catch(() => null);
+        if (org?.preview_subdomain) {
+            liveUrl = `https://${org.preview_subdomain}.makeautonomous.com${finalSlug}`;
+        }
+    }
+    // Machine output: the live URL is carried as `subdomain_url` — the same field
+    // name `funnel get`/`list`/`create` use — so an agent that pushes has the URL
+    // in hand without a follow-up `funnel get` (and without guessing the field).
+    if (flags.json) {
+        printJson({
+            slug: finalSlug,
+            subdomain_url: liveUrl ?? null,
+            overwritten: Boolean(clash),
+            org_id: orgId,
+            funnel_id: funnelId,
+        });
+        return;
+    }
     success(`Pushed ${clash ? '(overwrote) ' : ''}page to ${finalSlug}`);
     info(`Org:    ${orgLabel}`);
     info(`Funnel: ${funnelLabel}`);
     if (resolvedFromOrg) {
         info(`(Auto-picked the org's only funnel. Pin it explicitly with --funnel ${funnelId} or: myapi config set-funnel ${funnelId})`);
     }
-    let liveUrl = result?.url;
-    if (!liveUrl) {
-        const org = await hq.getOrg(config.api_key, orgId);
-        if (org.preview_subdomain) {
-            liveUrl = `https://${org.preview_subdomain}.makeautonomous.com${finalSlug}`;
-        }
-    }
     if (liveUrl)
         info(`Preview: ${liveUrl}`);
     // If we're still on the preview subdomain, hint at how to serve on a
@@ -563,7 +579,7 @@ Examples:
   myapi funnel publish ./dist                    # prod — refused if a site exists
   myapi funnel publish ./dist --force            # prod — replace existing site
   myapi funnel publish ./site --api-fn <function_id>`,
-    'push': `myapi funnel push [slug] [--funnel <id>] [--slug <path>] [--force] [--org <id>] < page.html
+    'push': `myapi funnel push [slug] [--funnel <id>] [--slug <path>] [--force] [--org <id>] [--json] < page.html
 
 Reads HTML from stdin and publishes to <slug> on your funnel. Funnel is resolved
 from --funnel, the default funnel, or (only if the org has exactly one) auto-picked.
@@ -573,6 +589,10 @@ exists there, push refuses and names the org + funnel + slug at risk; re-run
 with --force to replace it. On success it prints the resolved org + funnel so
 you can confirm you wrote to the namespace you intended.
 
+With --json, prints { slug, subdomain_url, overwritten, org_id, funnel_id } —
+the live URL is carried as subdomain_url (same field name as funnel get/list),
+so you don't need a follow-up "funnel get" to find where the page went.
+
 By default, your funnel is served on a preview subdomain (*.makeautonomous.com).
 To serve on your own domain, register and assign one with:
   myapi domain register <domain>

package/dist/commands/git.js

@@ -1,8 +1,10 @@
+import * as fs from 'fs';
+import * as path from 'path';
 import { git as sdkGit } from '@myapihq/sdk';
 import { requireConfig } from '../config.js';
 import { success, error, printTable, info, printJson } from '../output.js';
-import { formatDate } from '../utils.js';
-import { requireOrg, requireArg } from '../helpers.js';
+import { formatDate, retryFunds } from '../utils.js';
+import { requireOrg, requireArg, confirmDestructive } from '../helpers.js';
 export const EXPOSES = [
     'POST /git/orgs/{org_id}/repos',
     'GET /git/orgs/{org_id}/repos',
@@ -35,11 +37,62 @@ export const SCHEMA = {
     'author-name': 'string',
     'author-email': 'string',
     changes: 'string',
+    dir: 'string',
+    file: 'string',
+    as: 'string',
     target: 'string',
     source: 'string',
 };
 const shortSha = (s) => (s || '').slice(0, 8);
 const firstLine = (s) => (s || '').split('\n')[0];
+// Build a commit's file changes from local disk (--dir / --file), falling back
+// to an explicit --changes JSON array. This is the ergonomic path an agent
+// actually needs: point at a directory of generated code, not hand-author JSON.
+function collectChanges(flags) {
+    const changes = [];
+    const toChange = (abs, repoPath) => {
+        const buf = fs.readFileSync(abs);
+        // Binary files (null byte present) go base64; everything else UTF-8 text.
+        return buf.includes(0)
+            ? { path: repoPath, content_base64: buf.toString('base64') }
+            : { path: repoPath, content: buf.toString('utf-8') };
+    };
+    if (typeof flags.dir === 'string' && flags.dir) {
+        const root = flags.dir;
+        if (!fs.existsSync(root) || !fs.statSync(root).isDirectory())
+            error(`--dir: not a directory: ${root}`);
+        const walk = (d) => {
+            for (const ent of fs.readdirSync(d, { withFileTypes: true })) {
+                if (ent.name === '.git' || ent.name === 'node_modules')
+                    continue;
+                const abs = path.join(d, ent.name);
+                if (ent.isDirectory())
+                    walk(abs);
+                else if (ent.isFile())
+                    changes.push(toChange(abs, path.relative(root, abs).split(path.sep).join('/')));
+            }
+        };
+        walk(root);
+    }
+    if (typeof flags.file === 'string' && flags.file) {
+        if (!fs.existsSync(flags.file))
+            error(`--file: not found: ${flags.file}`);
+        const repoPath = (typeof flags.as === 'string' && flags.as) ? flags.as : path.basename(flags.file);
+        changes.push(toChange(flags.file, repoPath));
+    }
+    if (typeof flags.changes === 'string' && flags.changes) {
+        try {
+            const parsed = JSON.parse(flags.changes);
+            if (!Array.isArray(parsed))
+                throw new Error('not an array');
+            changes.push(...parsed);
+        }
+        catch (e) {
+            error(`--changes is not valid JSON: ${e?.message ?? e}`);
+        }
+    }
+    return changes;
+}
 // ── Repos ────────────────────────────────────────────────────────────────────
 export async function create(name, flags) {
     const config = requireConfig();
@@ -79,10 +132,11 @@ export async function get(repo, flags) {
 }
 export async function del(repo, flags) {
     const config = requireConfig();
-    const orgId = requireOrg(flags, config, 'myapi git delete <repo> [--org <id>]');
+    const orgId = requireOrg(flags, config, 'myapi git delete <repo> [--yes] [--org <id>]');
     requireArg(repo, 'repo', 'myapi git delete <repo>');
+    await confirmDestructive(flags, `delete repository "${repo}" in org ${orgId}`, 'myapi git delete <repo> --yes [--org <id>]');
     await sdkGit.deleteRepo(config.api_key, orgId, repo);
-    success(`Deleted repository ${repo}`);
+    success(`Deleted repository ${repo} (org ${orgId})`);
 }
 // ── Refs / history ───────────────────────────────────────────────────────────
 export async function refs(repo, flags) {
@@ -94,12 +148,15 @@ export async function refs(repo, flags) {
         printJson(r);
         return;
     }
-    info(`HEAD: ${r.head}`);
-    info(`Branches (${r.branches.length}):`);
-    for (const b of r.branches)
+    // branches/tags come back null (not []) on a repo with none — guard both.
+    const branches = r.branches ?? [];
+    const tags = r.tags ?? [];
+    info(`HEAD: ${r.head ?? '(none)'}`);
+    info(`Branches (${branches.length}):`);
+    for (const b of branches)
         info(`  ${b.name}  ${shortSha(b.sha)}`);
-    info(`Tags (${r.tags.length}):`);
-    for (const t of r.tags)
+    info(`Tags (${tags.length}):`);
+    for (const t of tags)
         info(`  ${t.name}  ${shortSha(t.sha)}`);
 }
 export async function log(repo, flags) {
@@ -188,37 +245,45 @@ export async function diff(repo, flags) {
 // ── Writes ───────────────────────────────────────────────────────────────────
 export async function commit(repo, flags) {
     const config = requireConfig();
-    const orgId = requireOrg(flags, config, 'myapi git commit <repo> --branch <b> --message <m> --changes <json> [--org <id>]');
-    requireArg(repo, 'repo', 'myapi git commit <repo> --branch <b> --message <m> --changes <json>');
+    const usage = 'myapi git commit <repo> --branch <b> --message <m> (--dir <path> | --file <path> [--as <repo-path>] | --changes <json>)';
+    const orgId = requireOrg(flags, config, usage);
+    requireArg(repo, 'repo', usage);
     const branch = flags.branch;
     if (!branch)
-        error('Missing --branch.\nUsage: myapi git commit <repo> --branch <b> --message <m> --changes <json>');
-    if (typeof flags.changes !== 'string') {
-        error('Missing --changes.\n--changes is a JSON array of file edits, e.g.\n  --changes \'[{"path":"README.md","content":"# Hello"}]\'\nEach entry: {path, content | content_base64 | delete:true, mode?}.');
-    }
-    let changes;
-    try {
-        changes = JSON.parse(flags.changes);
-        if (!Array.isArray(changes))
-            throw new Error('not an array');
-    }
-    catch (e) {
-        error(`--changes is not valid JSON: ${e?.message ?? e}`);
+        error(`Missing --branch.\nUsage: ${usage}`);
+    const changes = collectChanges(flags);
+    if (changes.length === 0) {
+        error(`Nothing to commit. Provide one of:\n  --dir <path>      commit every file under a local directory\n  --file <path>     commit a single local file (--as <repo-path> to rename)\n  --changes <json>  explicit edits: [{"path":"README.md","content":"# Hello"}]`);
     }
     const payload = {
-        branch,
+        branch: branch,
         message: flags.message || '',
-        changes: changes,
+        changes,
     };
-    if (typeof flags.base === 'string')
+    // Base resolution (optimistic concurrency). Explicit --base wins. Otherwise
+    // auto-resolve so the command "just works": if the branch exists, target its
+    // current tip; if it doesn't, send "" (create). Without this an agent would
+    // have to fetch the tip SHA itself, and a second commit fails REF_CONFLICT.
+    if (typeof flags.base === 'string') {
         payload.base = flags.base;
+    }
+    else {
+        // A failed ref read must abort — swallowing it would be indistinguishable
+        // from "branch doesn't exist" and silently switch the commit to
+        // create-semantics (base "") against an existing branch.
+        const refs = await sdkGit.listRefs(config.api_key, orgId, repo).catch((e) => {
+            error(`Could not read refs for "${repo}" (${e instanceof Error ? e.message : String(e)}).\nRefusing to guess the commit base — retry, or pass --base <sha> explicitly.`);
+        });
+        const tip = refs.branches?.find(b => b.name === branch)?.sha;
+        payload.base = tip ?? '';
+    }
     if (flags['author-name'] || flags['author-email']) {
         payload.author = {
             name: flags['author-name'] || '',
             email: flags['author-email'] || '',
         };
     }
-    const res = await sdkGit.commit(config.api_key, orgId, repo, payload);
+    const res = await retryFunds(() => sdkGit.commit(config.api_key, orgId, repo, payload));
     if (flags.json) {
         printJson(res);
         return;
@@ -291,15 +356,23 @@ const SUBCOMMAND_USAGE = {
     'tree': 'myapi git tree <repo> <ref> [--path <p>] [--org <id>] [--json]',
     'blob': 'myapi git blob <repo> <ref> <path> [--org <id>]\n\nPrints the file content (decoded). --json gives {path, size, content_base64}.',
     'diff': 'myapi git diff <repo> --base <ref> --head <ref> [--org <id>]',
-    'commit': `myapi git commit <repo> --branch <b> --message <m> --changes <json> [--base <ref>] [--author-name <n>] [--author-email <e>] [--org <id>]
+    'commit': `myapi git commit <repo> --branch <b> --message <m> (--dir <path> | --file <path> [--as <repo-path>] | --changes <json>) [--base <ref>] [--author-name <n>] [--author-email <e>] [--org <id>]
+
+Source the files to commit from local disk or explicit JSON (combinable):
+  --dir <path>      commit every file under a local directory (recursive;
+                    skips .git/ and node_modules/; binary files auto-base64)
+  --file <path>     commit a single local file (--as <repo-path> to rename it
+                    in the repo; defaults to the file's basename)
+  --changes <json>  explicit edits — array of
+                    {path, content | content_base64 | delete:true, mode?}
 
---changes is a JSON array of file edits — each entry is
-{path, content | content_base64 | delete:true, mode?}. Example:
-  myapi git commit my-repo --branch main --message "init" \\
-    --changes '[{"path":"README.md","content":"# Hello"}]'
+Examples:
+  myapi git commit site --branch main --message "init" --dir ./public
+  myapi git commit site --branch main --message "add page" --file ./out.html --as index.html
+  myapi git commit site --branch main --message "rm" --changes '[{"path":"old.txt","delete":true}]'
 
---base is the expected current branch tip (optimistic concurrency);
-omit it to create the branch, or pass it to guard against a stale write.`,
+--base is the expected current branch tip (optimistic concurrency); omit it to
+create the branch or write onto its current tip, or pass it to guard a stale write.`,
     'create-branch': 'myapi git create-branch <repo> <name> --from <ref> [--org <id>]',
     'delete-branch': 'myapi git delete-branch <repo> <branch> [--org <id>]',
     'tag': 'myapi git tag <repo> <name> --ref <ref> [--org <id>]',
@@ -327,7 +400,7 @@ History & content:
   refs <repo>             List branches and tags
 
 Writes:
-  commit <repo>           Commit file changes (--branch, --message, --changes)
+  commit <repo>           Commit files (--branch, --message, --dir | --file | --changes)
   create-branch <repo> <name>   Create a branch (--from <ref>)
   delete-branch <repo> <branch> Delete a branch
   tag <repo> <name>       Create a tag (--ref <ref>)