@adkit.so/cli 1.0.0

package/dist/commands/meta.js

@@ -0,0 +1,534 @@
+import { validateFlags } from '../cli-utils.js';
+import { getDefaultAccount } from '../config.js';
+import { CliError } from '../errors.js';
+import { IMAGE_HASH_RE, VIDEO_ID_RE } from '@adkit/shared/manage/meta/media-utils';
+/** Parse a JSON string and validate it's a plain object. Returns unknown — callers cast to the target type. */
+function parseJsonObject(raw, label) {
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        throw new CliError('INVALID_VALUE', `Invalid JSON in \`--${label}\``, `Check JSON syntax in --${label}`);
+    }
+    if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed))
+        throw new CliError('INVALID_VALUE', `Expected a JSON object in \`--${label}\``, `Check JSON syntax in --${label}`);
+    return parsed;
+}
+function dateStamp() {
+    return new Date().toISOString().slice(0, 10);
+}
+function generateCampaignName() {
+    return `campaign ${dateStamp()}`;
+}
+function generateAdSetName() {
+    return `adset ${dateStamp()}`;
+}
+function generateAdName() {
+    return `ad ${dateStamp()}`;
+}
+function generateCreativeName() {
+    return `creative ${dateStamp()}`;
+}
+function requireArg(args, index, label, hint) {
+    const val = args[index];
+    if (!val)
+        throw new CliError('MISSING_ARGUMENT', `Missing required argument: \`<${label}>\``, hint);
+    return val;
+}
+function requireFlag(flags, key, hint) {
+    const val = flags[key];
+    if (typeof val !== 'string')
+        throw new CliError('MISSING_FLAG', `Missing required flag: \`--${key}\``, hint);
+    return val;
+}
+function parseDataFlag(flags, hint) {
+    const raw = requireFlag(flags, 'data', hint);
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        const truncated = raw.length > 80 ? raw.slice(0, 80) + '...' : raw;
+        throw new CliError('INVALID_VALUE', `Invalid JSON in \`--data\` flag: ${truncated}`, 'Check JSON syntax in --data');
+    }
+}
+function mergeAccountId(body, flags) {
+    if (typeof body !== 'object' || body === null || Array.isArray(body))
+        return body;
+    const obj = body;
+    if (!obj.accountId) {
+        if (typeof flags.account === 'string')
+            obj.accountId = flags.account;
+        else {
+            const defaultAccount = getDefaultAccount('meta');
+            if (defaultAccount)
+                obj.accountId = defaultAccount;
+        }
+    }
+    return obj;
+}
+function flagStr(flags, key) {
+    const val = flags[key];
+    if (typeof val === 'string')
+        return val;
+    if (Array.isArray(val))
+        return val[0];
+    return undefined;
+}
+function flagArr(flags, key) {
+    const val = flags[key];
+    if (Array.isArray(val))
+        return val;
+    if (typeof val === 'string')
+        return [val];
+    return [];
+}
+function queryString(params) {
+    const entries = Object.entries(params).filter((e) => e[1] !== undefined);
+    if (entries.length === 0)
+        return '';
+    return '?' + entries.map(([k, v]) => `${k}=${encodeURIComponent(v)}`).join('&');
+}
+/** Type guard for MediaUploadResult — checks discriminated union tag and payload fields. */
+function isMediaUploadResult(value) {
+    if (typeof value !== 'object' || value === null)
+        return false;
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion -- narrowing after null check
+    const obj = value;
+    return (obj.type === 'image' && typeof obj.imageHash === 'string') || (obj.type === 'video' && typeof obj.videoId === 'string');
+}
+// --- Accounts ---
+export async function listAccounts(client, _args, _flags) {
+    return client.get('/manage/meta/accounts');
+}
+export async function connectAccount(client, args, _flags) {
+    const id = requireArg(args, 0, 'account-id', 'Run: adkit manage meta accounts connect <account-id>');
+    return client.post('/manage/meta/accounts/connect', { id });
+}
+export async function disconnectAccount(client, args, _flags) {
+    const id = requireArg(args, 0, 'account-id', 'Run: adkit manage meta accounts disconnect <account-id>');
+    return client.delete(`/manage/meta/accounts/${id}`);
+}
+export async function listPages(client, args, _flags) {
+    const id = requireArg(args, 0, 'account-id', 'Run: adkit manage meta accounts <account-id> pages');
+    return client.get(`/manage/meta/accounts/${id}/pages`);
+}
+export async function listPixels(client, args, _flags) {
+    const id = requireArg(args, 0, 'account-id', 'Run: adkit manage meta accounts <account-id> pixels');
+    return client.get(`/manage/meta/accounts/${id}/pixels`);
+}
+// --- Campaigns ---
+function buildCampaignPayload(flags) {
+    const payload = {};
+    if (typeof flags.name === 'string')
+        payload.name = flags.name;
+    // Server validates enum values — CLI forwards raw input
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion -- server validates enum, CLI forwards raw string
+    if (typeof flags.objective === 'string')
+        payload.objective = flags.objective;
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion -- server validates enum, CLI forwards raw string
+    if (typeof flags.status === 'string')
+        payload.status = flags.status;
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion -- server validates enum, CLI forwards raw string
+    if (typeof flags['bid-strategy'] === 'string')
+        payload.bidStrategy = flags['bid-strategy'];
+    // CBO is ON by default (matches Meta UI). Use --abo for adset-level budget.
+    if (flags.abo === true)
+        payload.advantageCampaignBudget = false;
+    else
+        payload.advantageCampaignBudget = true;
+    // Budget
+    if (typeof flags['budget-daily'] === 'string')
+        payload.budget = { daily: parseFloat(flags['budget-daily']) };
+    if (typeof flags['budget-total'] === 'string')
+        payload.budget = { ...payload.budget, lifetime: parseFloat(flags['budget-total']) };
+    // JSON flags
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion -- raw JSON from user flag, server validates shape
+    if (typeof flags['platform-overrides'] === 'string')
+        payload.platformOverrides = parseJsonObject(flags['platform-overrides'], 'platform-overrides');
+    return payload;
+}
+export async function listCampaigns(client, _args, flags) {
+    validateFlags(flags, [], 'manage meta campaigns list');
+    const accountId = typeof flags.account === 'string' ? flags.account : undefined;
+    const qs = queryString({ accountId });
+    return client.get(`/manage/meta/campaigns${qs}`);
+}
+const CAMPAIGN_FLAGS = ['name', 'objective', 'status', 'budget-daily', 'budget-total', 'abo', 'bid-strategy'];
+const ADSET_FLAGS = ['campaign', 'name', 'status', 'optimization', 'budget-daily', 'budget-total', 'countries', 'genders', 'targeting', 'pixel', 'event-type', 'interest'];
+const AD_FLAGS = ['creative', 'adset', 'name', 'status', 'media', 'primary-text', 'headline', 'description', 'cta', 'url', 'page'];
+const CREATIVE_FLAGS = ['page-id', 'headline', 'primary-text', 'link-description', 'link-url', 'cta', 'name', 'image-hash', 'image-url', 'video-id', 'force'];
+const MEDIA_FLAGS = ['file', 'url', 'account'];
+export async function createCampaign(client, _args, flags) {
+    if (typeof flags.data === 'string') {
+        const body = parseDataFlag(flags, 'Check JSON syntax in --data');
+        mergeAccountId(body, flags);
+        const publish = flags.publish === true ? '?publish=true' : '';
+        return client.post(`/manage/meta/campaigns${publish}`, body);
+    }
+    validateFlags(flags, CAMPAIGN_FLAGS, 'manage meta campaigns create');
+    const payload = buildCampaignPayload(flags);
+    if (!payload.name)
+        payload.name = generateCampaignName();
+    const body = { campaigns: [payload] };
+    mergeAccountId(body, flags);
+    const publish = flags.publish === true ? '?publish=true' : '';
+    return client.post(`/manage/meta/campaigns${publish}`, body);
+}
+export async function updateCampaign(client, args, flags) {
+    const id = requireArg(args, 0, 'campaign-id', `Run: adkit manage meta campaigns update <campaign-id> --status paused`);
+    if (typeof flags.data === 'string') {
+        const body = parseDataFlag(flags, 'Check JSON syntax in --data');
+        mergeAccountId(body, flags);
+        return client.patch(`/manage/meta/campaigns/${id}`, body);
+    }
+    validateFlags(flags, CAMPAIGN_FLAGS, 'manage meta campaigns update');
+    const payload = buildCampaignPayload(flags);
+    mergeAccountId(payload, flags);
+    return client.patch(`/manage/meta/campaigns/${id}`, payload);
+}
+export async function deleteCampaign(client, args, _flags) {
+    const id = requireArg(args, 0, 'campaign-id', 'Run: adkit manage meta campaigns delete <campaign-id>');
+    return client.delete(`/manage/meta/campaigns/${id}`);
+}
+// --- AdSets ---
+function buildAdSetPayload(flags) {
+    const payload = {};
+    if (typeof flags.campaign === 'string')
+        payload.campaignId = flags.campaign;
+    if (typeof flags.name === 'string')
+        payload.name = flags.name;
+    // Server validates enum values — CLI forwards raw input
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion -- server validates enum, CLI forwards raw string
+    if (typeof flags.status === 'string')
+        payload.status = flags.status;
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion -- server validates enum, CLI forwards raw string
+    if (typeof flags.optimization === 'string')
+        payload.optimization = flags.optimization;
+    // Budget
+    if (typeof flags['budget-daily'] === 'string')
+        payload.budget = { daily: parseFloat(flags['budget-daily']) };
+    if (typeof flags['budget-total'] === 'string')
+        payload.budget = { ...payload.budget, lifetime: parseFloat(flags['budget-total']) };
+    // Targeting (simple flags)
+    const targeting = {};
+    if (typeof flags.countries === 'string')
+        targeting.countries = flags.countries.split(',');
+    // --interest (repeatable) → targeting.interests
+    if (Array.isArray(flags.interest))
+        targeting.interests = flags.interest;
+    else if (typeof flags.interest === 'string')
+        targeting.interests = [flags.interest];
+    // Deep-merge --targeting JSON (takes precedence for nested keys)
+    if (typeof flags.targeting === 'string')
+        Object.assign(targeting, parseJsonObject(flags.targeting, 'targeting'));
+    if (Object.keys(targeting).length)
+        payload.targeting = targeting;
+    // Conversion tracking convenience flags
+    if (typeof flags.pixel === 'string')
+        payload.pixelId = flags.pixel;
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion -- server validates enum, CLI forwards raw string
+    if (typeof flags['event-type'] === 'string')
+        payload.eventType = flags['event-type'];
+    // JSON flags
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion -- raw JSON from user flag, server validates shape
+    if (typeof flags['platform-overrides'] === 'string')
+        payload.platformOverrides = parseJsonObject(flags['platform-overrides'], 'platform-overrides');
+    return payload;
+}
+export async function listAdSets(client, _args, flags) {
+    validateFlags(flags, ['campaign'], 'manage meta adsets list');
+    const accountId = typeof flags.account === 'string' ? flags.account : undefined;
+    const campaignId = typeof flags.campaign === 'string' ? flags.campaign : undefined;
+    const qs = queryString({ accountId, campaignId });
+    return client.get(`/manage/meta/adsets${qs}`);
+}
+export async function createAdSet(client, _args, flags) {
+    if (typeof flags.data === 'string') {
+        const body = parseDataFlag(flags, 'Check JSON syntax in --data');
+        mergeAccountId(body, flags);
+        const publish = flags.publish === true ? '?publish=true' : '';
+        return client.post(`/manage/meta/adsets${publish}`, body);
+    }
+    validateFlags(flags, ADSET_FLAGS, 'manage meta adsets create');
+    const payload = buildAdSetPayload(flags);
+    if (!payload.campaignId)
+        throw new CliError('MISSING_FLAG', 'Missing required flag: `--campaign`', 'Run: adkit manage meta adsets create --campaign cmp_abc --name "US 25-44" --budget-daily 20 --optimization link_clicks');
+    if (!payload.name)
+        payload.name = generateAdSetName();
+    const body = { adsets: [payload] };
+    mergeAccountId(body, flags);
+    const publish = flags.publish === true ? '?publish=true' : '';
+    return client.post(`/manage/meta/adsets${publish}`, body);
+}
+export async function updateAdSet(client, args, flags) {
+    const id = requireArg(args, 0, 'adset-id', `Run: adkit manage meta adsets update <adset-id> --budget-daily 50`);
+    if (typeof flags.data === 'string') {
+        const body = parseDataFlag(flags, 'Check JSON syntax in --data');
+        mergeAccountId(body, flags);
+        return client.patch(`/manage/meta/adsets/${id}`, body);
+    }
+    validateFlags(flags, ADSET_FLAGS, 'manage meta adsets update');
+    const payload = buildAdSetPayload(flags);
+    mergeAccountId(payload, flags);
+    return client.patch(`/manage/meta/adsets/${id}`, payload);
+}
+export async function deleteAdSet(client, args, _flags) {
+    const id = requireArg(args, 0, 'adset-id', 'Run: adkit manage meta adsets delete <adset-id>');
+    return client.delete(`/manage/meta/adsets/${id}`);
+}
+// --- Ads ---
+export async function listAds(client, _args, flags) {
+    validateFlags(flags, ['adset'], 'manage meta ads list');
+    const accountId = typeof flags.account === 'string' ? flags.account : undefined;
+    const adsetId = typeof flags.adset === 'string' ? flags.adset : undefined;
+    const qs = queryString({ accountId, adsetId });
+    return client.get(`/manage/meta/ads${qs}`);
+}
+export async function createAd(client, _args, flags) {
+    // Low-level flow: --data bypasses the rich flow
+    if (typeof flags.data === 'string') {
+        const body = parseDataFlag(flags, 'Check JSON syntax in --data');
+        mergeAccountId(body, flags);
+        const publish = flags.publish === true ? '?publish=true' : '';
+        return client.post(`/manage/meta/ads${publish}`, body);
+    }
+    validateFlags(flags, AD_FLAGS, 'manage meta ads create');
+    const creativeId = typeof flags.creative === 'string' ? flags.creative : undefined;
+    const mediaFlags = ['media', 'primary-text', 'headline', 'description', 'cta'];
+    const hasMediaFlags = mediaFlags.some((f) => flags[f] !== undefined);
+    if (creativeId && hasMediaFlags)
+        throw new CliError('INVALID_VALUE', '`--creative` cannot be combined with --media, --primary-text, --headline, --description, or --cta', 'Use --creative to reference an existing creative, OR use --media/--primary-text/etc. to create a new one');
+    // Existing creative flow: --creative <id> → uses ads[] low-level API
+    if (creativeId) {
+        const adsetId = requireFlag(flags, 'adset', 'Run: adkit manage meta ads create --creative cr_abc --adset as_xyz --publish');
+        const ad = {
+            adsetId,
+            name: typeof flags.name === 'string' ? flags.name : generateAdName(),
+            creativeId,
+        };
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion -- server validates enum, CLI forwards raw string
+        if (typeof flags.status === 'string')
+            ad.status = flags.status;
+        const body = { ads: [ad] };
+        mergeAccountId(body, flags);
+        const publish = flags.publish === true ? '?publish=true' : '';
+        return client.post(`/manage/meta/ads${publish}`, body);
+    }
+    // New creative flow: --media, --primary-text, --headline, --cta, --adset
+    const mediaInputs = flagArr(flags, 'media');
+    const primaryTexts = flagArr(flags, 'primary-text');
+    const headlines = flagArr(flags, 'headline');
+    const descriptions = flagArr(flags, 'description');
+    if (mediaInputs.length === 0)
+        throw new CliError('MISSING_FLAG', 'Missing required flag: `--media` (or use `--creative` to reference an existing creative)', 'Run: adkit manage meta ads create --media ./hero.mp4 --primary-text "Hello" --adset as_xyz --publish');
+    const adsetId = typeof flags.adset === 'string' ? flags.adset : undefined;
+    if (!adsetId)
+        throw new CliError('MISSING_FLAG', 'Missing required flag: `--adset`', 'Run: adkit manage meta ads create --media ./hero.mp4 --adset as_789 --publish');
+    // Auto-detect: media ID (image hash or video ID) vs file path vs URL
+    function isMediaId(input) {
+        return IMAGE_HASH_RE.test(input) || VIDEO_ID_RE.test(input);
+    }
+    const mediaIds = [];
+    for (const input of mediaInputs) {
+        if (isMediaId(input)) {
+            // Already a resolved media ID — pass through directly
+            mediaIds.push(input);
+        }
+        else {
+            // File path or URL — upload first, extract returned ID
+            let uploadBody;
+            if (input.startsWith('http://') || input.startsWith('https://'))
+                uploadBody = { imageUrl: input };
+            else {
+                const fs = await import('node:fs');
+                const path = await import('node:path');
+                const VIDEO_EXTENSIONS = new Set(['.mp4', '.mov', '.avi', '.webm', '.mkv']);
+                const resolved = path.resolve(input);
+                const ext = path.extname(resolved).toLowerCase();
+                const filename = path.basename(resolved);
+                const base64 = fs.readFileSync(resolved).toString('base64');
+                if (VIDEO_EXTENSIONS.has(ext))
+                    uploadBody = { videoBase64: base64, filename };
+                else
+                    uploadBody = { imageBase64: base64, filename };
+            }
+            const result = await client.post('/manage/meta/media', uploadBody);
+            if (!isMediaUploadResult(result))
+                throw new CliError('SERVER_ERROR', 'Media upload did not return an image hash or video ID');
+            const id = result.type === 'image' ? result.imageHash : result.videoId;
+            mediaIds.push(id);
+        }
+    }
+    const ad = { adsetId, mediaIds };
+    if (primaryTexts.length)
+        ad.primaryTexts = primaryTexts;
+    if (headlines.length)
+        ad.headlines = headlines;
+    if (descriptions.length)
+        ad.descriptions = descriptions;
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion -- server validates enum, CLI forwards raw string
+    if (typeof flags.cta === 'string')
+        ad.cta = flags.cta;
+    if (typeof flags.name === 'string')
+        ad.name = flags.name;
+    if (typeof flags.url === 'string')
+        ad.url = flags.url;
+    if (typeof flags.page === 'string')
+        ad.pageId = flags.page;
+    const body = { ads: [ad] };
+    mergeAccountId(body, flags);
+    const publish = flags.publish === true ? '?publish=true' : '';
+    return client.post(`/manage/meta/ads${publish}`, body);
+}
+export async function updateAd(client, args, flags) {
+    const id = requireArg(args, 0, 'ad-id', `Run: adkit manage meta ads update <ad-id> --data '{"status":"paused"}'`);
+    const body = parseDataFlag(flags, 'Check JSON syntax in --data');
+    mergeAccountId(body, flags);
+    return client.patch(`/manage/meta/ads/${id}`, body);
+}
+export async function deleteAd(client, args, _flags) {
+    const id = requireArg(args, 0, 'ad-id', 'Run: adkit manage meta ads delete <ad-id>');
+    return client.delete(`/manage/meta/ads/${id}`);
+}
+// --- Creatives ---
+function buildCreativePayload(flags) {
+    const payload = {};
+    const pageId = flagStr(flags, 'page-id');
+    const linkUrl = flagStr(flags, 'link-url');
+    const cta = flagStr(flags, 'cta');
+    const name = flagStr(flags, 'name');
+    const imageHash = flagStr(flags, 'image-hash');
+    const imageUrl = flagStr(flags, 'image-url');
+    const videoId = flagStr(flags, 'video-id');
+    if (pageId)
+        payload.pageId = pageId;
+    if (linkUrl)
+        payload.linkUrl = linkUrl;
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion -- server validates enum, CLI forwards raw string
+    if (cta)
+        payload.cta = cta;
+    if (name)
+        payload.name = name;
+    if (imageHash)
+        payload.imageHash = imageHash;
+    if (imageUrl)
+        payload.imageUrl = imageUrl;
+    if (videoId)
+        payload.videoId = videoId;
+    // Array fields (repeatable flags)
+    const headlines = flagArr(flags, 'headline');
+    if (headlines.length)
+        payload.headlines = headlines;
+    const primaryTexts = flagArr(flags, 'primary-text');
+    if (primaryTexts.length)
+        payload.primaryTexts = primaryTexts;
+    const linkDescriptions = flagArr(flags, 'link-description');
+    if (linkDescriptions.length)
+        payload.linkDescriptions = linkDescriptions;
+    // JSON flags
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion -- raw JSON from user flag, server validates shape
+    if (typeof flags['platform-overrides'] === 'string')
+        payload.platformOverrides = parseJsonObject(flags['platform-overrides'], 'platform-overrides');
+    return payload;
+}
+export async function createCreative(client, _args, flags) {
+    if (typeof flags.data === 'string') {
+        const body = parseDataFlag(flags, 'Check JSON syntax in --data');
+        mergeAccountId(body, flags);
+        const publish = flags.publish === true ? '?publish=true' : '';
+        return client.post(`/manage/meta/creatives${publish}`, body);
+    }
+    validateFlags(flags, CREATIVE_FLAGS, 'manage meta creatives create');
+    const payload = buildCreativePayload(flags);
+    if (!payload.pageId)
+        throw new CliError('MISSING_FLAG', 'Missing required flag: `--page-id`', 'Run: adkit manage meta creatives create --page-id pg_123 --headline "Get Started" --primary-text "Try it free" --link-url https://example.com');
+    if (!payload.headlines?.length)
+        throw new CliError('MISSING_FLAG', 'Missing required flag: `--headline`', 'Run: adkit manage meta creatives create --page-id pg_123 --headline "Get Started" --primary-text "Try it free" --link-url https://example.com');
+    if (!payload.primaryTexts?.length)
+        throw new CliError('MISSING_FLAG', 'Missing required flag: `--primary-text`', 'Run: adkit manage meta creatives create --page-id pg_123 --headline "Get Started" --primary-text "Try it free" --link-url https://example.com');
+    if (!payload.linkUrl)
+        throw new CliError('MISSING_FLAG', 'Missing required flag: `--link-url`', 'Run: adkit manage meta creatives create --page-id pg_123 --headline "Get Started" --primary-text "Try it free" --link-url https://example.com');
+    // Multi-asset detection: standalone creatives with multiple text variants
+    // use Dynamic Creative format, which Meta doesn't support for all objectives.
+    const isMultiAsset = (payload.headlines?.length ?? 0) > 1 || (payload.primaryTexts?.length ?? 0) > 1 || (payload.linkDescriptions?.length ?? 0) > 1;
+    if (isMultiAsset && flags.force !== true)
+        throw new CliError('INVALID_VALUE', "Standalone creatives with multiple assets use Dynamic Creative format, which Meta doesn't support for sales/app_promotion. Use `ads create` instead (auto-detects the right format). Add --force to proceed anyway.");
+    if (!payload.name)
+        payload.name = generateCreativeName();
+    mergeAccountId(payload, flags);
+    const publish = flags.publish === true ? '?publish=true' : '';
+    return client.post(`/manage/meta/creatives${publish}`, payload);
+}
+export async function updateCreative(client, args, flags) {
+    const id = requireArg(args, 0, 'creative-id', `Run: adkit manage meta creatives update <creative-id> --primary-text "Start free trial"`);
+    if (typeof flags.data === 'string') {
+        const body = parseDataFlag(flags, 'Check JSON syntax in --data');
+        mergeAccountId(body, flags);
+        return client.patch(`/manage/meta/creatives/${id}`, body);
+    }
+    validateFlags(flags, CREATIVE_FLAGS, 'manage meta creatives update');
+    const payload = buildCreativePayload(flags);
+    mergeAccountId(payload, flags);
+    return client.patch(`/manage/meta/creatives/${id}`, payload);
+}
+export async function deleteCreative(client, args, _flags) {
+    const id = requireArg(args, 0, 'creative-id', 'Run: adkit manage meta creatives delete <creative-id>');
+    return client.delete(`/manage/meta/creatives/${id}`);
+}
+// --- Interests ---
+export async function searchInterests(client, args, flags) {
+    if (!args.length)
+        throw new CliError('MISSING_ARGUMENT', 'Missing query', 'Run: adkit manage meta interests search <query> [query2] [query3]');
+    const accountId = typeof flags.account === 'string' ? flags.account : undefined;
+    const allResults = [];
+    for (const query of args) {
+        const qs = queryString({ accountId, q: query });
+        const res = await client.get(`/manage/meta/interests/search${qs}`);
+        const obj = res && typeof res === 'object' && 'results' in res ? res : null;
+        const arr = obj && Array.isArray(obj.results) ? obj.results : [];
+        for (const item of arr)
+            allResults.push(item);
+    }
+    return { results: allResults };
+}
+// --- Media ---
+export async function uploadMedia(client, _args, flags) {
+    validateFlags(flags, MEDIA_FLAGS, 'manage meta media upload');
+    const filePath = typeof flags.file === 'string' ? flags.file : undefined;
+    const url = typeof flags.url === 'string' ? flags.url : undefined;
+    if (!filePath && !url)
+        throw new CliError('MISSING_FLAG', 'Missing required flag: `--file` or `--url`', 'Run: adkit manage meta media upload --file ./video.mp4');
+    if (filePath) {
+        const fs = await import('node:fs');
+        const path = await import('node:path');
+        const resolved = path.resolve(filePath);
+        const ext = path.extname(resolved).toLowerCase();
+        const isVideo = ['.mp4', '.mov', '.avi', '.webm', '.mkv'].includes(ext);
+        const base64 = fs.readFileSync(resolved).toString('base64');
+        const filename = path.basename(resolved);
+        if (isVideo)
+            return client.post('/manage/meta/media', { videoBase64: base64, filename });
+        else
+            return client.post('/manage/meta/media', { imageBase64: base64, filename });
+    }
+    // URL-based upload — detect video vs image from URL extension
+    if (!url)
+        throw new CliError('MISSING_FLAG', 'Missing required flag: `--file` or `--url`');
+    const VIDEO_EXTENSIONS = new Set(['.mp4', '.mov', '.avi', '.mkv', '.webm']);
+    const urlExt = new URL(url).pathname.match(/\.[^.]+$/)?.[0]?.toLowerCase() ?? '';
+    if (VIDEO_EXTENSIONS.has(urlExt))
+        return client.post('/manage/meta/media', { videoUrl: url });
+    return client.post('/manage/meta/media', { imageUrl: url });
+}
+export async function listMedia(client, _args, flags) {
+    const accountId = typeof flags.account === 'string' ? flags.account : undefined;
+    const qs = queryString({ accountId });
+    return client.get(`/manage/meta/media${qs}`);
+}
+export async function deleteMedia(client, args, flags) {
+    const id = requireArg(args, 0, 'media-id', 'Run: adkit manage meta media delete <media-id>');
+    const accountId = typeof flags.account === 'string' ? flags.account : undefined;
+    const qs = queryString({ accountId });
+    return client.delete(`/manage/meta/media/${id}${qs}`);
+}

package/dist/commands/projects.d.ts

@@ -0,0 +1,25 @@
+interface ProjectConfig {
+    apiKey?: string;
+    selectedProject?: string;
+    projects?: Record<string, {
+        name: string;
+        apiKey: string;
+    }>;
+}
+export interface ProjectEntry {
+    id: string;
+    name: string;
+    apiKey: string;
+    current?: boolean;
+}
+/** Returns a formatted list of all configured projects. */
+export declare function listProjects(config: ProjectConfig): ProjectEntry[];
+/** Writes selectedProject to config, making projectId the active project. */
+export declare function useProject(projectId: string): void;
+/** Returns info about the current default project, or null if none is set. */
+export declare function currentProject(config: ProjectConfig): {
+    id: string;
+    name: string;
+    apiKey: string;
+} | null;
+export {};

package/dist/commands/projects.js

@@ -0,0 +1,30 @@
+import { readConfig, writeConfig } from '../config.js';
+/** Returns a formatted list of all configured projects. */
+export function listProjects(config) {
+    if (!config.projects)
+        return [];
+    return Object.entries(config.projects).map(([id, value]) => {
+        const entry = { id, name: value.name, apiKey: value.apiKey };
+        if (config.selectedProject === id) {
+            entry.current = true;
+        }
+        return entry;
+    });
+}
+/** Writes selectedProject to config, making projectId the active project. */
+export function useProject(projectId) {
+    const config = readConfig() ?? {};
+    if (!config.projects?.[projectId]) {
+        throw new Error(`Project not found: ${projectId}`);
+    }
+    writeConfig({ selectedProject: projectId });
+}
+/** Returns info about the current default project, or null if none is set. */
+export function currentProject(config) {
+    if (!config.selectedProject)
+        return null;
+    const entry = config.projects?.[config.selectedProject];
+    if (!entry)
+        return null;
+    return { id: config.selectedProject, name: entry.name, apiKey: entry.apiKey };
+}

package/dist/commands/status.d.ts

@@ -0,0 +1,2 @@
+import type { AdkitClient } from '../client.js';
+export declare function status(client: AdkitClient, json: boolean): Promise<void>;

package/dist/commands/status.js

@@ -0,0 +1,36 @@
+export async function status(client, json) {
+    const data = (await client.get('/manage/status'));
+    if (json) {
+        console.log(JSON.stringify(data));
+        return;
+    }
+    const { project, platforms } = data;
+    const lines = [];
+    lines.push(`Project: ${project.name || 'unnamed'} (${project.id})`);
+    lines.push('');
+    // Meta
+    if (platforms.meta.connected) {
+        lines.push('Meta: connected');
+        for (const a of platforms.meta.accounts) {
+            lines.push(`  ${a.id} — ${a.name} (${a.currency}, ${a.status})`);
+            if (a.defaults.pageId)
+                lines.push(`    Page: ${a.defaults.pageId}`);
+            if (a.defaults.pixelId)
+                lines.push(`    Pixel: ${a.defaults.pixelId}`);
+        }
+    }
+    else {
+        lines.push('Meta: not connected');
+    }
+    // Google
+    if (platforms.google.connected) {
+        lines.push('Google: connected');
+        for (const a of platforms.google.accounts) {
+            lines.push(`  ${a.id} — ${a.name} (${a.currency})`);
+        }
+    }
+    else {
+        lines.push('Google: not connected');
+    }
+    console.log(lines.join('\n'));
+}

package/dist/config.d.ts

@@ -0,0 +1,24 @@
+export declare const CONFIG_DIR: string;
+export declare const CONFIG_PATH: string;
+interface ConfigFile {
+    apiKey?: string;
+    selectedProject?: string;
+    projects?: Record<string, {
+        name: string;
+        apiKey: string;
+        defaultMetaAccount?: string;
+        defaultGoogleAccount?: string;
+    }>;
+}
+interface ResolvedConfig {
+    apiKey: string | null;
+    selectedProject?: string;
+}
+interface ResolveFlags {
+    project?: string;
+}
+export declare function readConfig(): ConfigFile | null;
+export declare function writeConfig(updates: Partial<ConfigFile>): void;
+export declare function resolveConfig(flags?: ResolveFlags): ResolvedConfig;
+export declare function getDefaultAccount(platform: 'meta' | 'google'): string | null;
+export {};