@myapihq/cli 1.2.8 → 1.2.9

package/dist/commands/email/index.js

@@ -31,6 +31,7 @@ export const SCHEMA = {
     prompt: 'string',
     name: 'string',
     emails: 'string',
+    quick: 'boolean',
     'per-day': 'number',
     file: 'string',
 };

package/dist/commands/email/verify.d.ts

@@ -3,5 +3,5 @@ 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 VERIFY_HELP = "Usage: myapi email verify <email> [--org <id>] [--json]\n\nSync single-address email verification. Cheap layer only: syntax + DNS +\nMicrosoft GetCredentialType. Returns a verdict in <1s for ~50% of inputs;\nthe rest get verdict='unknown' with smtp_recommended=true.\n\nVerdicts:\n  deliverable    high-confidence \u2014 the address accepts mail\n  undeliverable  high-confidence \u2014 syntax bad, DNS missing, or Microsoft rejects\n  unknown        not enough signal; consider an SMTP probe (not in this API)\n\nUse --json for the full check breakdown (syntax / DNS / Microsoft probes).\n";
-export declare function run(emailArg: string | undefined, _rest: string[], flags?: Flags): Promise<void>;
+export declare const VERIFY_HELP = "Usage: myapi email verify <email> [--org <id>] [--json]\n       myapi email verify bulk [--quick] [--org <id>] < emails.txt\n       myapi email verify job <job_id> [--org <id>] [--json]\n\nSingle-address verification (sync): syntax + DNS + Microsoft probe.\nReturns a verdict in <1s for ~50% of inputs; the rest get\nverdict='unknown' with smtp_recommended=true.\n\nBulk verification (async): reads up to 500 addresses from stdin (one per\nline), starts a job, and prints a job_id. It runs the cheap verdict on\nevery address then SMTP-probes the uncertain ones. --quick skips the\ncatch-all check (faster, but catch-all domains aren't flagged). Poll with\n\"myapi email verify job <job_id>\".\n";
+export declare function run(arg: string | undefined, rest: string[], flags?: Flags): Promise<void>;

package/dist/commands/email/verify.js

@@ -1,31 +1,85 @@
 import { email as sdkEmail } from '@myapihq/sdk';
 import { requireConfig } from '../../config.js';
-import { error, info, printJson } from '../../output.js';
+import { success, error, info, printTable, printJson } from '../../output.js';
 import { requireOrg } from '../../helpers.js';
 export const EXPOSES = [
     'POST /email/orgs/{org_id}/verify',
+    'POST /email/orgs/{org_id}/verify-bulk',
+    'GET /email/orgs/{org_id}/verify-jobs/{id}',
 ];
 export const SCHEMA = {};
 export const VERIFY_HELP = `Usage: myapi email verify <email> [--org <id>] [--json]
+       myapi email verify bulk [--quick] [--org <id>] < emails.txt
+       myapi email verify job <job_id> [--org <id>] [--json]
 
-Sync single-address email verification. Cheap layer only: syntax + DNS +
-Microsoft GetCredentialType. Returns a verdict in <1s for ~50% of inputs;
-the rest get verdict='unknown' with smtp_recommended=true.
+Single-address verification (sync): syntax + DNS + Microsoft probe.
+Returns a verdict in <1s for ~50% of inputs; the rest get
+verdict='unknown' with smtp_recommended=true.
 
-Verdicts:
-  deliverable    high-confidence — the address accepts mail
-  undeliverable  high-confidence — syntax bad, DNS missing, or Microsoft rejects
-  unknown        not enough signal; consider an SMTP probe (not in this API)
-
-Use --json for the full check breakdown (syntax / DNS / Microsoft probes).
+Bulk verification (async): reads up to 500 addresses from stdin (one per
+line), starts a job, and prints a job_id. It runs the cheap verdict on
+every address then SMTP-probes the uncertain ones. --quick skips the
+catch-all check (faster, but catch-all domains aren't flagged). Poll with
+"myapi email verify job <job_id>".
 `;
-export async function run(emailArg, _rest, flags = {}) {
-    if (flags.help) {
-        info(VERIFY_HELP);
+async function readStdinLines() {
+    if (process.stdin.isTTY) {
+        error('No input on stdin. Pipe a newline-separated list of addresses:\n  myapi email verify bulk < emails.txt');
+    }
+    const data = await new Promise((resolve, reject) => {
+        let buf = '';
+        process.stdin.setEncoding('utf-8');
+        process.stdin.on('data', c => { buf += c; });
+        process.stdin.on('end', () => resolve(buf));
+        process.stdin.on('error', reject);
+    });
+    return data.split('\n').map(l => l.trim()).filter(Boolean);
+}
+async function bulk(flags) {
+    const config = requireConfig();
+    const orgId = requireOrg(flags, config, 'myapi email verify bulk [--quick] [--org <id>] < emails.txt');
+    const emails = await readStdinLines();
+    if (emails.length === 0)
+        error('No addresses on stdin. Provide a newline-separated list.');
+    if (emails.length > 500)
+        error(`Too many addresses (${emails.length}). The bulk limit is 500 per job.`);
+    // --quick turns off the catch-all check (catchAll=false).
+    const job = await sdkEmail.verifyBulk(config.api_key, orgId, emails, flags.quick ? false : undefined);
+    if (flags.json) {
+        printJson(job);
+        return;
+    }
+    success(`Bulk verification started — ${job.total} address(es)`);
+    info(`Job: ${job.job_id}  ·  status: ${job.status}`);
+    info(`Poll it with: myapi email verify job ${job.job_id}`);
+}
+async function job(jobId, flags) {
+    if (!jobId)
+        error('Missing job id.\nUsage: myapi email verify job <job_id>');
+    const config = requireConfig();
+    const orgId = requireOrg(flags, config, 'myapi email verify job <job_id> [--org <id>]');
+    const res = await sdkEmail.getVerifyJob(config.api_key, orgId, jobId);
+    if (flags.json) {
+        printJson(res);
         return;
     }
-    if (!emailArg)
-        error('Missing required argument <email>.\nUsage: myapi email verify <email> [--org <id>] [--json]');
+    info(`Job:        ${res.job_id}`);
+    info(`Status:     ${res.status}`);
+    info(`Progress:   ${res.completed ?? 0} / ${res.total}`);
+    if (res.error)
+        info(`Error:      ${res.error}`);
+    if (res.results && res.results.length > 0) {
+        info('');
+        printTable(res.results.map(r => ({
+            email: r.email,
+            verdict: r.verdict,
+            confidence: r.confidence.toFixed(2),
+            source: r.source,
+            detail: r.detail || '',
+        })), { flags });
+    }
+}
+async function single(emailArg, flags) {
     const config = requireConfig();
     const orgId = requireOrg(flags, config, 'myapi email verify <email> [--org <id>]');
     const res = await sdkEmail.verifyEmail(config.api_key, orgId, emailArg);
@@ -38,7 +92,7 @@ export async function run(emailArg, _rest, flags = {}) {
             : '? unknown';
     info(`Email:      ${res.email}`);
     info(`Verdict:    ${verdictLabel}  (confidence ${res.confidence.toFixed(2)})`);
-    info(`SMTP next:  ${res.smtp_recommended ? 'yes — consider an SMTP probe' : 'no — verdict is definitive'}`);
+    info(`SMTP next:  ${res.smtp_recommended ? 'yes — consider a bulk job (SMTP-probes the uncertain ones)' : 'no — verdict is definitive'}`);
     info(`Took:       ${res.elapsed_ms}ms`);
     if (res.checks.syntax.detail)
         info(`Syntax:     ${res.checks.syntax.detail}`);
@@ -50,3 +104,18 @@ export async function run(emailArg, _rest, flags = {}) {
     if (res.checks.microsoft)
         info(`Microsoft:  ${res.checks.microsoft.verdict}`);
 }
+// `arg` is the first token after `verify`: the literal `bulk` / `job`
+// selects the async modes; anything else is treated as a single address.
+export async function run(arg, rest, flags = {}) {
+    if (flags.help) {
+        info(VERIFY_HELP);
+        return;
+    }
+    if (arg === 'bulk')
+        return bulk(flags);
+    if (arg === 'job')
+        return job(rest[0], flags);
+    if (!arg)
+        error('Missing required argument <email>.\nUsage: myapi email verify <email>  (or: verify bulk | verify job <id>)');
+    return single(arg, flags);
+}

package/dist/commands/git.d.ts

@@ -0,0 +1,22 @@
+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 function create(name: string, flags: Flags): Promise<void>;
+export declare function list(flags: Flags): Promise<void>;
+export declare function get(repo: string, flags: Flags): Promise<void>;
+export declare function del(repo: string, flags: Flags): Promise<void>;
+export declare function refs(repo: string, flags: Flags): Promise<void>;
+export declare function log(repo: string, flags: Flags): Promise<void>;
+export declare function show(repo: string, sha: string, flags: Flags): Promise<void>;
+export declare function tree(repo: string, ref: string, flags: Flags): Promise<void>;
+export declare function blob(repo: string, ref: string, path: string, flags: Flags): Promise<void>;
+export declare function diff(repo: string, flags: Flags): Promise<void>;
+export declare function commit(repo: string, flags: Flags): Promise<void>;
+export declare function createBranch(repo: string, name: string, flags: Flags): Promise<void>;
+export declare function deleteBranch(repo: string, branch: string, flags: Flags): Promise<void>;
+export declare function tag(repo: string, name: string, flags: Flags): Promise<void>;
+export declare function merge(repo: string, flags: Flags): Promise<void>;
+export declare function repack(repo: string, flags: Flags): Promise<void>;
+export declare function run(subcommand: string | undefined, args: string[], flags: Flags): Promise<void>;

package/dist/commands/git.js

@@ -0,0 +1,367 @@
+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';
+export const EXPOSES = [
+    'POST /git/orgs/{org_id}/repos',
+    'GET /git/orgs/{org_id}/repos',
+    'GET /git/orgs/{org_id}/repos/{repo}',
+    'DELETE /git/orgs/{org_id}/repos/{repo}',
+    'GET /git/orgs/{org_id}/repos/{repo}/refs',
+    'GET /git/orgs/{org_id}/repos/{repo}/tree/{ref}',
+    'GET /git/orgs/{org_id}/repos/{repo}/blob/{ref}/{path}',
+    'GET /git/orgs/{org_id}/repos/{repo}/commits',
+    'GET /git/orgs/{org_id}/repos/{repo}/commits/{sha}',
+    'GET /git/orgs/{org_id}/repos/{repo}/diff',
+    'POST /git/orgs/{org_id}/repos/{repo}/commits',
+    'POST /git/orgs/{org_id}/repos/{repo}/branches',
+    'DELETE /git/orgs/{org_id}/repos/{repo}/branches/{branch}',
+    'POST /git/orgs/{org_id}/repos/{repo}/tags',
+    'POST /git/orgs/{org_id}/repos/{repo}/merges',
+    'POST /git/orgs/{org_id}/repos/{repo}/repack',
+];
+export const SCHEMA = {
+    name: 'string',
+    'default-branch': 'string',
+    ref: 'string',
+    limit: 'number',
+    path: 'string',
+    base: 'string',
+    head: 'string',
+    branch: 'string',
+    message: 'string',
+    from: 'string',
+    'author-name': 'string',
+    'author-email': 'string',
+    changes: 'string',
+    target: 'string',
+    source: 'string',
+};
+const shortSha = (s) => (s || '').slice(0, 8);
+const firstLine = (s) => (s || '').split('\n')[0];
+// ── Repos ────────────────────────────────────────────────────────────────────
+export async function create(name, flags) {
+    const config = requireConfig();
+    const orgId = requireOrg(flags, config, 'myapi git create <name> [--default-branch <b>] [--org <id>]');
+    const repoName = name || flags.name;
+    requireArg(repoName, 'name', 'myapi git create <name> [--default-branch <b>]');
+    const res = await sdkGit.createRepo(config.api_key, orgId, repoName, flags['default-branch']);
+    success(`Repository created: ${res.name}`);
+    info(`Default branch: ${res.default_branch}`);
+}
+export async function list(flags) {
+    const config = requireConfig();
+    const orgId = requireOrg(flags, config, 'myapi git list [--org <id>]');
+    const repos = await sdkGit.listRepos(config.api_key, orgId);
+    if (flags.json) {
+        printJson(repos);
+        return;
+    }
+    printTable(repos.map(r => ({ name: r.name })), {
+        flags,
+        empty: 'No repositories yet. Create one with: myapi git create <name>',
+    });
+}
+export async function get(repo, flags) {
+    const config = requireConfig();
+    const orgId = requireOrg(flags, config, 'myapi git get <repo> [--org <id>]');
+    requireArg(repo, 'repo', 'myapi git get <repo>');
+    const r = await sdkGit.getRepo(config.api_key, orgId, repo);
+    if (flags.json) {
+        printJson(r);
+        return;
+    }
+    info(`Name:            ${r.name}`);
+    info(`Default branch:  ${r.default_branch}`);
+    info(`Branches:        ${r.branches}`);
+    info(`Tags:            ${r.tags}`);
+}
+export async function del(repo, flags) {
+    const config = requireConfig();
+    const orgId = requireOrg(flags, config, 'myapi git delete <repo> [--org <id>]');
+    requireArg(repo, 'repo', 'myapi git delete <repo>');
+    await sdkGit.deleteRepo(config.api_key, orgId, repo);
+    success(`Deleted repository ${repo}`);
+}
+// ── Refs / history ───────────────────────────────────────────────────────────
+export async function refs(repo, flags) {
+    const config = requireConfig();
+    const orgId = requireOrg(flags, config, 'myapi git refs <repo> [--org <id>]');
+    requireArg(repo, 'repo', 'myapi git refs <repo>');
+    const r = await sdkGit.listRefs(config.api_key, orgId, repo);
+    if (flags.json) {
+        printJson(r);
+        return;
+    }
+    info(`HEAD: ${r.head}`);
+    info(`Branches (${r.branches.length}):`);
+    for (const b of r.branches)
+        info(`  ${b.name}  ${shortSha(b.sha)}`);
+    info(`Tags (${r.tags.length}):`);
+    for (const t of r.tags)
+        info(`  ${t.name}  ${shortSha(t.sha)}`);
+}
+export async function log(repo, flags) {
+    const config = requireConfig();
+    const orgId = requireOrg(flags, config, 'myapi git log <repo> [--ref <r>] [--limit <n>] [--org <id>]');
+    requireArg(repo, 'repo', 'myapi git log <repo>');
+    const commits = await sdkGit.listCommits(config.api_key, orgId, repo, {
+        ref: flags.ref,
+        limit: typeof flags.limit === 'number' ? flags.limit : undefined,
+    });
+    if (flags.json) {
+        printJson(commits);
+        return;
+    }
+    printTable(commits.map(c => ({
+        sha: shortSha(c.sha),
+        message: firstLine(c.message),
+        author: c.author,
+        when: c.when ? formatDate(c.when) : '',
+    })), { flags, empty: 'No commits.' });
+}
+export async function show(repo, sha, flags) {
+    const config = requireConfig();
+    const orgId = requireOrg(flags, config, 'myapi git show <repo> <sha> [--org <id>]');
+    requireArg(repo, 'repo', 'myapi git show <repo> <sha>');
+    requireArg(sha, 'sha', 'myapi git show <repo> <sha>');
+    const c = await sdkGit.getCommit(config.api_key, orgId, repo, sha);
+    if (flags.json) {
+        printJson(c);
+        return;
+    }
+    info(`Commit:  ${c.sha}`);
+    info(`Author:  ${c.author} <${c.email}>`);
+    info(`Date:    ${c.when ? formatDate(c.when) : ''}`);
+    if (c.parents?.length)
+        info(`Parents: ${c.parents.map(shortSha).join(' ')}`);
+    info('');
+    info(c.message);
+}
+export async function tree(repo, ref, flags) {
+    const config = requireConfig();
+    const orgId = requireOrg(flags, config, 'myapi git tree <repo> <ref> [--path <p>] [--org <id>]');
+    requireArg(repo, 'repo', 'myapi git tree <repo> <ref>');
+    requireArg(ref, 'ref', 'myapi git tree <repo> <ref>');
+    const entries = await sdkGit.listTree(config.api_key, orgId, repo, ref, flags.path);
+    if (flags.json) {
+        printJson(entries);
+        return;
+    }
+    printTable(entries.map(e => ({
+        type: e.type,
+        mode: e.mode,
+        size: e.type === 'file' ? e.size : '',
+        path: e.path,
+    })), { flags, empty: 'Empty tree.' });
+}
+export async function blob(repo, ref, path, flags) {
+    const config = requireConfig();
+    const orgId = requireOrg(flags, config, 'myapi git blob <repo> <ref> <path> [--org <id>]');
+    requireArg(repo, 'repo', 'myapi git blob <repo> <ref> <path>');
+    requireArg(ref, 'ref', 'myapi git blob <repo> <ref> <path>');
+    requireArg(path, 'path', 'myapi git blob <repo> <ref> <path>');
+    const b = await sdkGit.readBlob(config.api_key, orgId, repo, ref, path);
+    if (flags.json) {
+        printJson(b);
+        return;
+    }
+    // Decode and print the file content raw — `git blob` is a `cat`.
+    process.stdout.write(Buffer.from(b.content_base64, 'base64').toString('utf-8'));
+}
+export async function diff(repo, flags) {
+    const config = requireConfig();
+    const orgId = requireOrg(flags, config, 'myapi git diff <repo> --base <ref> --head <ref> [--org <id>]');
+    requireArg(repo, 'repo', 'myapi git diff <repo> --base <ref> --head <ref>');
+    const base = flags.base;
+    const head = flags.head;
+    if (!base || !head)
+        error('Both --base <ref> and --head <ref> are required.\nUsage: myapi git diff <repo> --base <ref> --head <ref>');
+    const text = await sdkGit.getDiff(config.api_key, orgId, repo, base, head);
+    if (flags.json) {
+        printJson({ diff: text });
+        return;
+    }
+    process.stdout.write(text.endsWith('\n') || text === '' ? text : text + '\n');
+}
+// ── 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 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}`);
+    }
+    const payload = {
+        branch,
+        message: flags.message || '',
+        changes: changes,
+    };
+    if (typeof flags.base === 'string')
+        payload.base = flags.base;
+    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);
+    if (flags.json) {
+        printJson(res);
+        return;
+    }
+    success(`Committed ${shortSha(res.sha)} to ${res.branch}`);
+    info(`Tree: ${shortSha(res.tree)}`);
+}
+export async function createBranch(repo, name, flags) {
+    const config = requireConfig();
+    const orgId = requireOrg(flags, config, 'myapi git create-branch <repo> <name> --from <ref> [--org <id>]');
+    requireArg(repo, 'repo', 'myapi git create-branch <repo> <name> --from <ref>');
+    requireArg(name, 'name', 'myapi git create-branch <repo> <name> --from <ref>');
+    const from = flags.from;
+    if (!from)
+        error('Missing --from <ref>.\nUsage: myapi git create-branch <repo> <name> --from <ref>');
+    await sdkGit.createBranch(config.api_key, orgId, repo, name, from);
+    success(`Created branch ${name} (from ${from})`);
+}
+export async function deleteBranch(repo, branch, flags) {
+    const config = requireConfig();
+    const orgId = requireOrg(flags, config, 'myapi git delete-branch <repo> <branch> [--org <id>]');
+    requireArg(repo, 'repo', 'myapi git delete-branch <repo> <branch>');
+    requireArg(branch, 'branch', 'myapi git delete-branch <repo> <branch>');
+    await sdkGit.deleteBranch(config.api_key, orgId, repo, branch);
+    success(`Deleted branch ${branch}`);
+}
+export async function tag(repo, name, flags) {
+    const config = requireConfig();
+    const orgId = requireOrg(flags, config, 'myapi git tag <repo> <name> --ref <ref> [--org <id>]');
+    requireArg(repo, 'repo', 'myapi git tag <repo> <name> --ref <ref>');
+    requireArg(name, 'name', 'myapi git tag <repo> <name> --ref <ref>');
+    const ref = flags.ref;
+    if (!ref)
+        error('Missing --ref <ref>.\nUsage: myapi git tag <repo> <name> --ref <ref>');
+    await sdkGit.createTag(config.api_key, orgId, repo, name, ref);
+    success(`Created tag ${name} → ${ref}`);
+}
+export async function merge(repo, flags) {
+    const config = requireConfig();
+    const orgId = requireOrg(flags, config, 'myapi git merge <repo> --target <b> --source <b> [--org <id>]');
+    requireArg(repo, 'repo', 'myapi git merge <repo> --target <b> --source <b>');
+    const target = flags.target;
+    const source = flags.source;
+    if (!target || !source)
+        error('Both --target <branch> and --source <branch> are required.\nUsage: myapi git merge <repo> --target <b> --source <b>\n(Merge is fast-forward only.)');
+    const res = await sdkGit.merge(config.api_key, orgId, repo, target, source);
+    success(`Merged ${source} into ${target} → ${shortSha(res.sha)}`);
+}
+export async function repack(repo, flags) {
+    const config = requireConfig();
+    const orgId = requireOrg(flags, config, 'myapi git repack <repo> [--org <id>]');
+    requireArg(repo, 'repo', 'myapi git repack <repo>');
+    const res = await sdkGit.repack(config.api_key, orgId, repo);
+    if (flags.json) {
+        printJson(res);
+        return;
+    }
+    success(`Repacked ${repo}`);
+    info(`Packs: ${res.packs_before} → ${res.packs_after}  ·  ${res.objects} objects`);
+}
+// ── Dispatcher ───────────────────────────────────────────────────────────────
+const SUBCOMMAND_USAGE = {
+    'create': 'myapi git create <name> [--default-branch <b>] [--org <id>]',
+    'list': 'myapi git list [--org <id>] [--json]',
+    'get': 'myapi git get <repo> [--org <id>] [--json]',
+    'delete': 'myapi git delete <repo> [--org <id>]',
+    'refs': 'myapi git refs <repo> [--org <id>] [--json]',
+    'log': 'myapi git log <repo> [--ref <r>] [--limit <n>] [--org <id>] [--json]',
+    'show': 'myapi git show <repo> <sha> [--org <id>] [--json]',
+    '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>]
+
+--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"}]'
+
+--base is the expected current branch tip (optimistic concurrency);
+omit it to create the branch, or pass it to guard against 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>]',
+    'merge': 'myapi git merge <repo> --target <branch> --source <branch> [--org <id>]\n\nFast-forward only.',
+    'repack': 'myapi git repack <repo> [--org <id>]',
+};
+export async function run(subcommand, args, flags) {
+    if (!subcommand || (flags.help && !subcommand)) {
+        info(`Usage: myapi git <subcommand>
+
+Hosted git repositories over HTTP — no local clone required.
+
+Repositories:
+  create <name>           Create a repository
+  list                    List repositories
+  get <repo>              Show a repository's branch/tag counts
+  delete <repo>           Delete a repository
+
+History & content:
+  log <repo>              List commits (--ref, --limit)
+  show <repo> <sha>       Show a single commit
+  tree <repo> <ref>       List a ref's file tree (--path)
+  blob <repo> <ref> <path>  Print a file's content
+  diff <repo>             Diff two refs (--base, --head)
+  refs <repo>             List branches and tags
+
+Writes:
+  commit <repo>           Commit file changes (--branch, --message, --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>)
+  merge <repo>            Fast-forward merge (--target, --source)
+  repack <repo>           Compact the repository's packfiles
+
+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 git --help" for the list.`);
+        return;
+    }
+    switch (subcommand) {
+        case 'create': return create(args[0], flags);
+        case 'list': return list(flags);
+        case 'get': return get(args[0], flags);
+        case 'delete': return del(args[0], flags);
+        case 'refs': return refs(args[0], flags);
+        case 'log': return log(args[0], flags);
+        case 'show': return show(args[0], args[1], flags);
+        case 'tree': return tree(args[0], args[1], flags);
+        case 'blob': return blob(args[0], args[1], args[2], flags);
+        case 'diff': return diff(args[0], flags);
+        case 'commit': return commit(args[0], flags);
+        case 'create-branch': return createBranch(args[0], args[1], flags);
+        case 'delete-branch': return deleteBranch(args[0], args[1], flags);
+        case 'tag': return tag(args[0], args[1], flags);
+        case 'merge': return merge(args[0], flags);
+        case 'repack': return repack(args[0], flags);
+        default: error(`Unknown subcommand: ${subcommand}. Run "myapi git --help" for a list of valid subcommands.`);
+    }
+}

package/dist/commands/pixel.js

@@ -135,9 +135,12 @@ export async function identity(pixelId, flags) {
     const config = requireConfig();
     const orgId = flags.org || config.default_org;
     if (!orgId || !pixelId) {
-        error("Missing required arguments.\nUsage: myapi pixel identity <pixel_id> --org <id>\n(Or set defaults via: myapi config set-org <id>)");
+        error("Missing required arguments.\nUsage: myapi pixel identity <pixel_id> --website <domain> [--org <id>]\n(Or set defaults via: myapi config set-org <id>)");
     }
-    const res = await sdkPixel.getIdentity(config.api_key, orgId, pixelId);
+    // Identity resolution is scoped to a website the org owns — required.
+    if (!flags.website)
+        error("Missing required arg: --website <domain>. Identity resolution is scoped to a host the org owns.");
+    const res = await sdkPixel.getIdentity(config.api_key, orgId, pixelId, flags.website);
     printJson(res);
 }
 // ── Dispatcher ───────────────────────────────────────────────────────────────
@@ -146,7 +149,7 @@ const SUBCOMMAND_USAGE = {
     'visits': 'myapi pixel visits --website <domain> [--from <iso8601>] [--to <iso8601>] [--limit <num>] [--offset <num>] [--org <id>] [--json]',
     'events': 'myapi pixel events [--campaign-id <id>] [--domain <domain>] [--from <iso8601>] [--to <iso8601>] [--limit <num>] [--offset <num>] [--org <id>] [--json]',
     'audience': 'myapi pixel audience [--org <id>]',
-    'identity': 'myapi pixel identity <pixel_id> [--org <id>]',
+    'identity': 'myapi pixel identity <pixel_id> --website <domain> [--org <id>]',
 };
 export async function run(subcommand, args, flags) {
     if (!subcommand || (flags.help && !subcommand)) {

package/dist/completion.js

@@ -27,7 +27,7 @@ const BLOCK_END = `# end ${PROGRAM} completion`;
 // is missing here.
 export const COMMANDS = [
     'audience', 'auth', 'billing', 'company', 'completion', 'config', 'container',
-    'crm', 'database', 'domain', 'email', 'fn', 'funnel', 'help', 'image',
+    'crm', 'database', 'domain', 'email', 'fn', 'funnel', 'git', 'help', 'image',
     'install-skills', 'keys', 'llm', 'org', 'payments', 'people', 'pixel',
     'setup', 'status', 'storage', 'update', 'url', 'webhook', 'whoami',
     'workflow',
@@ -58,6 +58,7 @@ export const SUBCOMMANDS = {
     fn: ['create', 'deploy', 'env', 'runs', 'list', 'get', 'delete'],
     payments: ['connect', 'status', 'charge', 'list', 'get', 'refund'],
     container: ['create', 'deploy', 'list', 'get', 'logs', 'delete'],
+    git: ['create', 'list', 'get', 'delete', 'refs', 'log', 'show', 'tree', 'blob', 'diff', 'commit', 'create-branch', 'delete-branch', 'tag', 'merge', 'repack'],
     completion: ['install', 'uninstall'],
 };
 // ── Completion request handling ──────────────────────────────────────────────

package/dist/exposes.test.js

@@ -40,6 +40,7 @@ const COMMAND_MODULES = [
     './commands/fn.js',
     './commands/payments.js',
     './commands/container.js',
+    './commands/git.js',
 ];
 const ENDPOINT_PATTERN = /^(GET|POST|PATCH|PUT|DELETE) \/[A-Za-z0-9_\-./{}]*$/;
 describe('every CLI command exports a typed EXPOSES array (S-101)', () => {

package/dist/index.js

@@ -32,6 +32,7 @@ import * as crmCmd from './commands/crm/index.js';
 import * as fnCmd from './commands/fn.js';
 import * as paymentsCmd from './commands/payments.js';
 import * as containerCmd from './commands/container.js';
+import * as gitCmd from './commands/git.js';
 // Each command file declares the value flags it understands. We union them
 // into a single schema for the upfront parse, so adding a new value flag in
 // one command means editing one file (its SCHEMA), not a global allowlist.
@@ -60,6 +61,7 @@ const COMBINED_SCHEMA = {
     ...fnCmd.SCHEMA,
     ...paymentsCmd.SCHEMA,
     ...containerCmd.SCHEMA,
+    ...gitCmd.SCHEMA,
     // Top-level flags
     version: 'boolean',
     V: 'boolean',
@@ -219,6 +221,9 @@ async function main() {
             case 'container':
                 await containerCmd.run(subcommand, restArgs, flags);
                 break;
+            case 'git':
+                await gitCmd.run(subcommand, restArgs, flags);
+                break;
             // Convenience aliases
             case 'setup':
                 await setupCmd.setup(flags);
@@ -342,6 +347,7 @@ const HELP_TARGETS = {
     fn: f => fnCmd.run(undefined, [], f),
     payments: f => paymentsCmd.run(undefined, [], f),
     container: f => containerCmd.run(undefined, [], f),
+    git: f => gitCmd.run(undefined, [], f),
     org: f => orgCmd.run(undefined, [], f),
     billing: f => billingCmd.run(undefined, [], f),
     keys: f => keysCmd.run(undefined, [], f),
@@ -385,6 +391,7 @@ Commands:
   funnel          Manage websites (publish pages, custom domains, funnels)
   fn              Create and deploy functions on the edge runtime
   container       Run containers — services, workers, and scheduled jobs
+  git             Hosted git repositories — repos, commits, branches, history
   payments        Take payments with Stripe Checkout (connect, charge, refund)
   webhook         Manage inbound webhook endpoints and inspect deliveries
   email           Manage mailboxes, send/read email, templates, and campaigns

package/dist/sdk-email-verify-bulk.test.d.ts

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

package/dist/sdk-email-verify-bulk.test.js

@@ -0,0 +1,57 @@
+// SDK-level unit tests for async bulk email verification —
+// email.verifyBulk + email.getVerifyJob. Mocks global fetch — no network.
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { email } from '@myapihq/sdk';
+const API_KEY = 'myapi_test_abc';
+const ORG = '11111111-1111-4111-8111-111111111111';
+let fetchMock;
+function ok(data) {
+    return new Response(JSON.stringify({ success: true, data, meta: {} }), {
+        status: 200, headers: { 'content-type': 'application/json' },
+    });
+}
+function fail(code, status) {
+    return new Response(JSON.stringify({ success: false, error: { code, message: code }, meta: {} }), {
+        status, headers: { 'content-type': 'application/json' },
+    });
+}
+beforeEach(() => { fetchMock = vi.fn(); globalThis.fetch = fetchMock; });
+afterEach(() => { vi.restoreAllMocks(); });
+describe('email.verifyBulk', () => {
+    it('POSTs {emails} and returns the job', async () => {
+        fetchMock.mockResolvedValueOnce(ok({ job_id: 'j1', status: 'pending', total: 2, catch_all: true }));
+        const job = await email.verifyBulk(API_KEY, ORG, ['a@x.com', 'b@y.com']);
+        const [url, init] = fetchMock.mock.calls[0];
+        expect(url).toContain(`/email/orgs/${ORG}/verify-bulk`);
+        expect(init.method).toBe('POST');
+        expect(JSON.parse(init.body)).toEqual({ emails: ['a@x.com', 'b@y.com'] });
+        expect(job.job_id).toBe('j1');
+    });
+    it('passes catch_all through when set', async () => {
+        fetchMock.mockResolvedValueOnce(ok({ job_id: 'j1', status: 'pending', total: 1 }));
+        await email.verifyBulk(API_KEY, ORG, ['a@x.com'], false);
+        expect(JSON.parse(fetchMock.mock.calls[0][1].body)).toEqual({ emails: ['a@x.com'], catch_all: false });
+    });
+    it('surfaces TOO_MANY_EMAILS (422)', async () => {
+        fetchMock.mockResolvedValueOnce(fail('TOO_MANY_EMAILS', 422));
+        await expect(email.verifyBulk(API_KEY, ORG, ['a@x.com']))
+            .rejects.toMatchObject({ code: 'TOO_MANY_EMAILS', status: 422 });
+    });
+});
+describe('email.getVerifyJob', () => {
+    it('GETs /verify-jobs/{id} and returns status + results', async () => {
+        fetchMock.mockResolvedValueOnce(ok({
+            job_id: 'j1', status: 'done', total: 1, completed: 1,
+            results: [{ email: 'a@x.com', verdict: 'deliverable', confidence: 0.9, source: 'smtp' }],
+        }));
+        const job = await email.getVerifyJob(API_KEY, ORG, 'j1');
+        expect(job.status).toBe('done');
+        expect(job.results?.[0].verdict).toBe('deliverable');
+        expect(fetchMock.mock.calls[0][0]).toContain(`/email/orgs/${ORG}/verify-jobs/j1`);
+    });
+    it('surfaces JOB_NOT_FOUND (404)', async () => {
+        fetchMock.mockResolvedValueOnce(fail('JOB_NOT_FOUND', 404));
+        await expect(email.getVerifyJob(API_KEY, ORG, 'nope'))
+            .rejects.toMatchObject({ code: 'JOB_NOT_FOUND', status: 404 });
+    });
+});

package/dist/sdk-git.test.d.ts

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

package/dist/sdk-git.test.js

@@ -0,0 +1,115 @@
+// SDK-level unit tests for the git module. Verifies URL/body shape,
+// envelope-unwrapping, path encoding, and error handling against
+// myapi-hq/internal/routes/git/. Mocks global fetch — no network.
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { git } from '@myapihq/sdk';
+const API_KEY = 'myapi_test_abc';
+const ORG = '11111111-1111-4111-8111-111111111111';
+let fetchMock;
+function ok(data, status = 200) {
+    return new Response(JSON.stringify({ success: true, data, meta: {} }), {
+        status, headers: { 'content-type': 'application/json' },
+    });
+}
+function fail(code, status) {
+    return new Response(JSON.stringify({ success: false, error: { code, message: code }, meta: {} }), {
+        status, headers: { 'content-type': 'application/json' },
+    });
+}
+beforeEach(() => { fetchMock = vi.fn(); globalThis.fetch = fetchMock; });
+afterEach(() => { vi.restoreAllMocks(); });
+describe('git repos', () => {
+    it('createRepo POSTs {name, default_branch?}', async () => {
+        fetchMock.mockResolvedValueOnce(ok({ name: 'app', default_branch: 'main' }, 201));
+        await git.createRepo(API_KEY, ORG, 'app', 'trunk');
+        const [url, init] = fetchMock.mock.calls[0];
+        expect(url).toContain(`/git/orgs/${ORG}/repos`);
+        expect(init.method).toBe('POST');
+        expect(JSON.parse(init.body)).toEqual({ name: 'app', default_branch: 'trunk' });
+    });
+    it('createRepo omits default_branch when not given', async () => {
+        fetchMock.mockResolvedValueOnce(ok({ name: 'app', default_branch: 'main' }, 201));
+        await git.createRepo(API_KEY, ORG, 'app');
+        expect(JSON.parse(fetchMock.mock.calls[0][1].body)).toEqual({ name: 'app' });
+    });
+    it('listRepos unwraps the {repos:[...]} envelope to an array', async () => {
+        fetchMock.mockResolvedValueOnce(ok({ repos: [{ name: 'a' }, { name: 'b' }] }));
+        expect(await git.listRepos(API_KEY, ORG)).toEqual([{ name: 'a' }, { name: 'b' }]);
+    });
+    it('getRepo GETs /repos/{repo}', async () => {
+        fetchMock.mockResolvedValueOnce(ok({ name: 'app', default_branch: 'main', branches: 2, tags: 1 }));
+        const r = await git.getRepo(API_KEY, ORG, 'app');
+        expect(r.branches).toBe(2);
+        expect(fetchMock.mock.calls[0][0]).toContain(`/git/orgs/${ORG}/repos/app`);
+    });
+    it('deleteRepo DELETEs and surfaces 404', async () => {
+        fetchMock.mockResolvedValueOnce(new Response(null, { status: 204 }));
+        await git.deleteRepo(API_KEY, ORG, 'app');
+        expect(fetchMock.mock.calls[0][1].method).toBe('DELETE');
+        fetchMock.mockResolvedValueOnce(fail('repository not found', 404));
+        await expect(git.deleteRepo(API_KEY, ORG, 'gone')).rejects.toMatchObject({ status: 404 });
+    });
+});
+describe('git history & content', () => {
+    it('listCommits passes ref/limit as query and unwraps {commits}', async () => {
+        fetchMock.mockResolvedValueOnce(ok({ commits: [{ sha: 'abc', message: 'init' }] }));
+        const commits = await git.listCommits(API_KEY, ORG, 'app', { ref: 'dev', limit: 10 });
+        expect(commits).toHaveLength(1);
+        const url = fetchMock.mock.calls[0][0];
+        expect(url).toMatch(/\/commits\?/);
+        expect(url).toContain('ref=dev');
+        expect(url).toContain('limit=10');
+    });
+    it('getDiff requires base+head and unwraps {diff}', async () => {
+        fetchMock.mockResolvedValueOnce(ok({ diff: '--- a\n+++ b\n' }));
+        const d = await git.getDiff(API_KEY, ORG, 'app', 'main', 'dev');
+        expect(d).toBe('--- a\n+++ b\n');
+        const url = fetchMock.mock.calls[0][0];
+        expect(url).toContain('base=main');
+        expect(url).toContain('head=dev');
+    });
+    it('listTree unwraps {entries} and adds ?path when scoped', async () => {
+        fetchMock.mockResolvedValueOnce(ok({ entries: [{ name: 'a.js', type: 'file' }] }));
+        await git.listTree(API_KEY, ORG, 'app', 'main', 'src');
+        expect(fetchMock.mock.calls[0][0]).toMatch(/\/tree\/main\?path=src$/);
+    });
+    it('readBlob encodes path segments but keeps the slashes', async () => {
+        fetchMock.mockResolvedValueOnce(ok({ path: 'src/a b.js', size: 3, content_base64: 'eA==' }));
+        await git.readBlob(API_KEY, ORG, 'app', 'main', 'src/a b.js');
+        // slashes survive (catch-all route), spaces within a segment are encoded
+        expect(fetchMock.mock.calls[0][0]).toMatch(/\/blob\/main\/src\/a%20b\.js$/);
+    });
+});
+describe('git writes', () => {
+    it('commit POSTs the full payload', async () => {
+        fetchMock.mockResolvedValueOnce(ok({ sha: 'def', tree: 't', branch: 'main' }, 201));
+        const res = await git.commit(API_KEY, ORG, 'app', {
+            branch: 'main', message: 'add', changes: [{ path: 'x', content: 'hi' }],
+        });
+        expect(res.sha).toBe('def');
+        expect(JSON.parse(fetchMock.mock.calls[0][1].body).changes).toHaveLength(1);
+    });
+    it('createBranch POSTs {name, from}', async () => {
+        fetchMock.mockResolvedValueOnce(ok({ name: 'feature' }, 201));
+        await git.createBranch(API_KEY, ORG, 'app', 'feature', 'main');
+        expect(JSON.parse(fetchMock.mock.calls[0][1].body)).toEqual({ name: 'feature', from: 'main' });
+    });
+    it('merge POSTs {target, source} and surfaces NOT_FAST_FORWARD (422)', async () => {
+        fetchMock.mockResolvedValueOnce(ok({ sha: 'ff' }));
+        expect((await git.merge(API_KEY, ORG, 'app', 'main', 'dev')).sha).toBe('ff');
+        fetchMock.mockResolvedValueOnce(fail('NOT_FAST_FORWARD', 422));
+        await expect(git.merge(API_KEY, ORG, 'app', 'main', 'dev')).rejects.toMatchObject({ status: 422 });
+    });
+    it('repack POSTs and returns the pack counts', async () => {
+        fetchMock.mockResolvedValueOnce(ok({ packs_before: 5, packs_after: 1, objects: 200 }));
+        const r = await git.repack(API_KEY, ORG, 'app');
+        expect(r).toEqual({ packs_before: 5, packs_after: 1, objects: 200 });
+    });
+});
+describe('git.EXPOSES', () => {
+    it('covers all 16 git endpoints', () => {
+        expect(git.EXPOSES).toHaveLength(16);
+        expect(git.EXPOSES).toContain('POST /git/orgs/{org_id}/repos/{repo}/commits');
+        expect(git.EXPOSES).toContain('GET /git/orgs/{org_id}/repos/{repo}/blob/{ref}/{path}');
+    });
+});

package/dist/skills/my-email-api/README.md

@@ -0,0 +1,45 @@
+---
+# my-email-api
+
+Send transactional email and run drip campaigns from mailboxes on your own registered domains. Includes AI template generation, warmup, and inbox/outbox reading.
+
+## What it does
+
+- Create mailboxes on your registered domains
+- Send transactional emails (one-shot or templated)
+- Read inbox, outbox, sent history, and per-message status
+- Generate HTML email templates with AI from a prompt
+- Run paced drip campaigns against uploaded contact lists
+- Manage IP/domain warmup for sender reputation
+
+## Quickstart
+
+```bash
+# Create a mailbox + activate sending
+myapi email mailbox create hello@yourdomain.com
+myapi email mailbox activate-sending --address hello@yourdomain.com
+
+# Send
+myapi email message send \
+  --from hello@yourdomain.com \
+  --to recipient@example.com \
+  --subject "Hi" \
+  --body "Test"
+```
+
+## Authentication
+
+```bash
+export MYAPI_KEY=mak_...
+```
+
+Requires:
+- An `api_key` from **myapihq**
+- A registered domain via **mydomainapi**, assigned to your org
+- Default `org_id` (for templates/campaigns) — set with `myapi auth config set-org <id>`
+
+## Documentation
+
+Full command reference and flow diagrams: see `SKILL.md`.
+
+Run `myapi email --help` for inline reference.

package/dist/skills/my-email-api/SKILL.md

@@ -0,0 +1,80 @@
+---
+name: my-email-api
+version: 1.0.0
+description: >
+  Send transactional and bulk email from your own domain. Create mailboxes, send/receive messages, generate AI templates, run drip campaigns, and manage warmup.
+triggers: [email, mailbox, send email, transactional email, drip campaign, template, warmup, inbox, outbox, ses, sender reputation]
+checksum: sha256-pending
+---
+
+# MyEmailAPI
+
+Account-scoped email infrastructure tied to your registered domains. Mailboxes belong to domains; sending and receiving work without per-org plumbing. Templates and campaigns are org-scoped.
+
+## Capabilities
+<!-- llm:start -->
+Email is built around mailboxes. Each mailbox lives on a registered domain (e.g. `hello@yourdomain.com`) and must be activated for sending before transactional sends or campaigns work — newly-created mailboxes can receive but not send.
+
+Templates are AI-generated HTML emails (org-scoped). Campaigns combine a template + a contact list + a per-day rate limit, sending to recipients over time. Warmup is a separate flow that gradually ramps a mailbox's send rate to build inbox reputation before high-volume campaigns.
+
+A registered domain via **mydomainapi** is the prerequisite — mailboxes need a domain to live on.
+<!-- llm:end -->
+
+## Commands
+<!-- generated:start -->
+| Namespace | Subcommands | Purpose |
+|---|---|---|
+| `email mailbox` | `create`, `list`, `activate-sending` | Create and manage mailboxes |
+| `email message` | `send`, `status`, `sent`, `inbox`, `outbox`, `get` | Transactional send + read |
+| `email warmup` | `start`, `stats`, `pause`, `resume`, `stop` | IP/domain warmup for sending reputation |
+| `email template` | `generate`, `list`, `get`, `preview`, `edit`, `send-test`, `delete` | AI-generated HTML templates |
+| `email campaign` | `create`, `list`, `get`, `update`, `upload-contacts`, `upload-contacts-file`, `start`, `pause`, `resume`, `stats` | Drip campaigns |
+<!-- generated:end -->
+
+## Examples
+<!-- llm:start -->
+```bash
+# 1. Create a mailbox + activate sending
+myapi email mailbox create hello@yourdomain.com --display-name "Hello"
+myapi email mailbox activate-sending --address hello@yourdomain.com
+
+# 2. Send a transactional email
+myapi email message send \
+  --from hello@yourdomain.com --to recipient@example.com \
+  --subject "Hi" --body "Test message"
+
+# 3. Read inbox / outbox
+myapi email message inbox  hello@yourdomain.com
+myapi email message outbox hello@yourdomain.com
+
+# 4. Generate + use a template
+myapi email template generate welcome-v1 \
+  --prompt "A welcome email with our brand colors and a CTA to /onboarding"
+myapi email template list
+myapi email template preview <id>            # public preview URL — share with stakeholders
+myapi email template send-test <id> --to me@yourdomain.com
+myapi email template edit <id> --prompt "Make the CTA larger and red"
+
+# 5. Drip campaign
+myapi email campaign create "Welcome series" \
+  --template-id <id> --from hello@yourdomain.com --per-day 50
+myapi email campaign upload-contacts <campaign_id> --emails "alice@x.com,bob@y.com"
+# (or for big lists)
+myapi email campaign upload-contacts-file <campaign_id> --file ./contacts.csv
+myapi email campaign start <campaign_id>
+myapi email campaign stats <campaign_id>
+
+# 6. Warm up before a big send
+myapi email warmup start --address hello@yourdomain.com
+myapi email warmup stats --address hello@yourdomain.com
+```
+<!-- llm:end -->
+
+## Notes
+
+- A mailbox is uniquely identified by its address (`username@domain`).
+- Sending is opt-in per mailbox. Newly-created mailboxes can receive but not send until `activate-sending` runs.
+- Templates and campaigns are org-scoped. Set a default org once: `myapi config set-org <id>`.
+- An active or paused campaign blocks `domain unassign` with `DOMAIN_IN_USE`.
+
+Run `myapi email --help` or `myapi email <namespace> --help` for full flag reference.

package/dist/skills/my-email-api/claude/.claude-plugin/plugin.json

@@ -0,0 +1,6 @@
+{
+  "name": "my-email-api",
+  "description": "Send transactional and bulk email from your own domain. Mailboxes, AI templates, drip campaigns, and warmup.",
+  "version": "1.0.0",
+  "published": true
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@myapihq/cli",
   "license": "Apache-2.0",
-  "version": "1.2.8",
+  "version": "1.2.9",
   "description": "MyAPI command-line interface",
   "type": "module",
   "files": [
@@ -29,7 +29,7 @@
     "lint:changelog": "node ../../scripts/lint-changelog.js"
   },
   "dependencies": {
-    "@myapihq/sdk": "^1.2.8"
+    "@myapihq/sdk": "^1.2.9"
   },
   "devDependencies": {
     "@types/node": "^25.6.0",