@myapihq/cli 1.2.8 → 1.3.0

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/mailbox.js

@@ -4,6 +4,8 @@ import { success, error, printTable, info } from '../../output.js';
 export const EXPOSES = [
     'POST /email/mailboxes/create',
     'GET /email/mailboxes',
+    'PUT /email/mailboxes/{address}/forwarding',
+    'DELETE /email/mailboxes/{address}/forwarding',
     'POST /email/sending/activate',
 ];
 async function create(addressArg, flags) {
@@ -52,6 +54,22 @@ async function activateSending(flags) {
     const res = await sdkEmail.activateSending(config.api_key, address);
     success(`Sending activated: ${address} (${res.emails_quota_remaining} emails/day quota)`);
 }
+async function setForwarding(address, forwardTo, _flags) {
+    const config = requireConfig();
+    if (!address || !forwardTo) {
+        error('Missing required arguments.\nUsage: myapi email mailbox set-forwarding <user@domain> <forward-to@domain>');
+    }
+    const res = await sdkEmail.setForwarding(config.api_key, address, forwardTo);
+    success(`Forwarding set: ${res.address} → ${res.forward_to}`);
+    info('A copy of every incoming message is redirected; the original is kept in the mailbox.');
+}
+async function clearForwarding(address, _flags) {
+    const config = requireConfig();
+    if (!address)
+        error('Missing required arguments.\nUsage: myapi email mailbox clear-forwarding <user@domain>');
+    await sdkEmail.deleteForwarding(config.api_key, address);
+    success(`Forwarding cleared for ${address}`);
+}
 const USAGE = {
     'create': `myapi email mailbox create <user@domain> [--display-name <name>]
        myapi email mailbox create --username <u> --domain <d> [--display-name <name>]
@@ -65,6 +83,11 @@ matches the rest of the CLI ("first required arg is positional").`,
                         org (orphaned mailboxes — domain was unassigned
                         without first deleting them).`,
     'activate-sending': 'myapi email mailbox activate-sending --address <email>',
+    'set-forwarding': `myapi email mailbox set-forwarding <user@domain> <forward-to@domain>
+
+Redirects a copy of every incoming message to an external address
+(server-side). The original is kept in the mailbox.`,
+    'clear-forwarding': 'myapi email mailbox clear-forwarding <user@domain>',
 };
 export async function run(sub, args, flags) {
     if (!sub || (flags.help && !sub)) {
@@ -73,7 +96,9 @@ export async function run(sub, args, flags) {
 Subcommands:
   create             Create a mailbox (positional <user@domain> or --username/--domain)
   list               List mailboxes on a domain (--domain) or orphaned ones (--filter unassigned)
-  activate-sending   Activate outbound sending for a mailbox`);
+  activate-sending   Activate outbound sending for a mailbox
+  set-forwarding     Forward a copy of incoming mail to an external address
+  clear-forwarding   Stop forwarding for a mailbox`);
         return;
     }
     if (flags.help) {
@@ -88,6 +113,8 @@ Subcommands:
         case 'create': return create(args[0], flags);
         case 'list': return list(flags);
         case 'activate-sending': return activateSending(flags);
+        case 'set-forwarding': return setForwarding(args[0], args[1], flags);
+        case 'clear-forwarding': return clearForwarding(args[0], flags);
         default: error(`Unknown subcommand: ${sub}. Run "myapi email mailbox --help" for the list.`);
     }
 }

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/commands/queue-validation.test.d.ts

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