zernio-cli 0.4.0

package/dist/commands/contacts.js

@@ -0,0 +1,198 @@
+import { createClient } from '../client.js';
+import { output } from '../utils/output.js';
+import { handleError } from '../utils/errors.js';
+/**
+ * Register contact commands: contacts:list, contacts:create, contacts:get, contacts:update,
+ * contacts:delete, contacts:channels, contacts:set-field, contacts:clear-field, contacts:bulk-create.
+ */
+export function registerContactCommands(yargs) {
+    return yargs
+        .command('contacts:list', 'List contacts', (y) => y
+        .option('profileId', { type: 'string', describe: 'Filter by profile ID' })
+        .option('search', { type: 'string', describe: 'Search by name, email, or phone' })
+        .option('tag', { type: 'string', describe: 'Filter by tag' })
+        .option('platform', { type: 'string', describe: 'Filter by platform' })
+        .option('isSubscribed', { type: 'string', describe: 'Filter by subscription status (true, false)' })
+        .option('limit', { type: 'number', describe: 'Max results', default: 50 })
+        .option('skip', { type: 'number', describe: 'Skip N results', default: 0 }), async (argv) => {
+        try {
+            const late = createClient();
+            const query = {
+                limit: argv.limit,
+                skip: argv.skip,
+            };
+            if (argv.profileId)
+                query.profileId = argv.profileId;
+            if (argv.search)
+                query.search = argv.search;
+            if (argv.tag)
+                query.tag = argv.tag;
+            if (argv.platform)
+                query.platform = argv.platform;
+            if (argv.isSubscribed)
+                query.isSubscribed = argv.isSubscribed;
+            const { data } = await late.contacts.listContacts({ query });
+            output(data, argv.pretty);
+        }
+        catch (err) {
+            handleError(err);
+        }
+    })
+        .command('contacts:create', 'Create a contact', (y) => y
+        .option('profileId', { type: 'string', describe: 'Profile ID', demandOption: true })
+        .option('name', { type: 'string', describe: 'Contact name', demandOption: true })
+        .option('email', { type: 'string', describe: 'Email address' })
+        .option('company', { type: 'string', describe: 'Company name' })
+        .option('tags', { type: 'string', describe: 'Comma-separated tags' })
+        .option('accountId', { type: 'string', describe: 'Account ID (creates a channel if provided with platform + platformIdentifier)' })
+        .option('platform', { type: 'string', describe: 'Platform for initial channel' })
+        .option('platformIdentifier', { type: 'string', describe: 'Platform user ID for initial channel' }), async (argv) => {
+        try {
+            const late = createClient();
+            const body = {
+                profileId: argv.profileId,
+                name: argv.name,
+            };
+            if (argv.email)
+                body.email = argv.email;
+            if (argv.company)
+                body.company = argv.company;
+            if (argv.tags)
+                body.tags = argv.tags.split(',').map((s) => s.trim());
+            if (argv.accountId)
+                body.accountId = argv.accountId;
+            if (argv.platform)
+                body.platform = argv.platform;
+            if (argv.platformIdentifier)
+                body.platformIdentifier = argv.platformIdentifier;
+            const { data } = await late.contacts.createContact({ body: body });
+            output(data, argv.pretty);
+        }
+        catch (err) {
+            handleError(err);
+        }
+    })
+        .command('contacts:get <id>', 'Get contact details', (y) => y.positional('id', { type: 'string', describe: 'Contact ID', demandOption: true }), async (argv) => {
+        try {
+            const late = createClient();
+            const { data } = await late.contacts.getContact({ path: { contactId: argv.id } });
+            output(data, argv.pretty);
+        }
+        catch (err) {
+            handleError(err);
+        }
+    })
+        .command('contacts:update <id>', 'Update a contact', (y) => y
+        .positional('id', { type: 'string', describe: 'Contact ID', demandOption: true })
+        .option('name', { type: 'string', describe: 'Contact name' })
+        .option('email', { type: 'string', describe: 'Email address' })
+        .option('company', { type: 'string', describe: 'Company name' })
+        .option('tags', { type: 'string', describe: 'Comma-separated tags (replaces existing)' })
+        .option('isSubscribed', { type: 'boolean', describe: 'Subscription status' })
+        .option('isBlocked', { type: 'boolean', describe: 'Block status' })
+        .option('notes', { type: 'string', describe: 'Contact notes' }), async (argv) => {
+        try {
+            const late = createClient();
+            const body = {};
+            if (argv.name)
+                body.name = argv.name;
+            if (argv.email)
+                body.email = argv.email;
+            if (argv.company)
+                body.company = argv.company;
+            if (argv.tags)
+                body.tags = argv.tags.split(',').map((s) => s.trim());
+            if (argv.isSubscribed !== undefined)
+                body.isSubscribed = argv.isSubscribed;
+            if (argv.isBlocked !== undefined)
+                body.isBlocked = argv.isBlocked;
+            if (argv.notes)
+                body.notes = argv.notes;
+            const { data } = await late.contacts.updateContact({
+                path: { contactId: argv.id },
+                body: body,
+            });
+            output(data, argv.pretty);
+        }
+        catch (err) {
+            handleError(err);
+        }
+    })
+        .command('contacts:delete <id>', 'Delete a contact', (y) => y.positional('id', { type: 'string', describe: 'Contact ID', demandOption: true }), async (argv) => {
+        try {
+            const late = createClient();
+            const { data } = await late.contacts.deleteContact({ path: { contactId: argv.id } });
+            output(data, argv.pretty);
+        }
+        catch (err) {
+            handleError(err);
+        }
+    })
+        .command('contacts:channels <id>', 'List channels for a contact', (y) => y.positional('id', { type: 'string', describe: 'Contact ID', demandOption: true }), async (argv) => {
+        try {
+            const late = createClient();
+            const { data } = await late.contacts.getContactChannels({ path: { contactId: argv.id } });
+            output(data, argv.pretty);
+        }
+        catch (err) {
+            handleError(err);
+        }
+    })
+        .command('contacts:set-field <id> <slug>', 'Set a custom field value on a contact', (y) => y
+        .positional('id', { type: 'string', describe: 'Contact ID', demandOption: true })
+        .positional('slug', { type: 'string', describe: 'Field slug', demandOption: true })
+        .option('value', { type: 'string', describe: 'Field value', demandOption: true }), async (argv) => {
+        try {
+            const late = createClient();
+            const { data } = await late.customfields.setContactFieldValue({
+                path: { contactId: argv.id, slug: argv.slug },
+                body: { value: argv.value },
+            });
+            output(data, argv.pretty);
+        }
+        catch (err) {
+            handleError(err);
+        }
+    })
+        .command('contacts:clear-field <id> <slug>', 'Clear a custom field value on a contact', (y) => y
+        .positional('id', { type: 'string', describe: 'Contact ID', demandOption: true })
+        .positional('slug', { type: 'string', describe: 'Field slug', demandOption: true }), async (argv) => {
+        try {
+            const late = createClient();
+            const { data } = await late.customfields.clearContactFieldValue({
+                path: { contactId: argv.id, slug: argv.slug },
+            });
+            output(data, argv.pretty);
+        }
+        catch (err) {
+            handleError(err);
+        }
+    })
+        .command('contacts:bulk-create', 'Bulk create up to 1000 contacts from a JSON file', (y) => y
+        .option('profileId', { type: 'string', describe: 'Profile ID', demandOption: true })
+        .option('accountId', { type: 'string', describe: 'Account ID', demandOption: true })
+        .option('platform', { type: 'string', describe: 'Platform', demandOption: true })
+        .option('file', { type: 'string', describe: 'Path to JSON file with contacts array', demandOption: true }), async (argv) => {
+        try {
+            const { readFileSync } = await import('fs');
+            const raw = readFileSync(argv.file, 'utf-8');
+            const contacts = JSON.parse(raw);
+            if (!Array.isArray(contacts)) {
+                throw new Error('JSON file must contain an array of contact objects');
+            }
+            const late = createClient();
+            const { data } = await late.contacts.bulkCreateContacts({
+                body: {
+                    profileId: argv.profileId,
+                    accountId: argv.accountId,
+                    platform: argv.platform,
+                    contacts,
+                },
+            });
+            output(data, argv.pretty);
+        }
+        catch (err) {
+            handleError(err);
+        }
+    });
+}

package/dist/commands/doctor.d.ts

@@ -0,0 +1,2 @@
+import type { Argv } from 'yargs';
+export declare function registerDoctorCommand(yargs: Argv): Argv;

package/dist/commands/doctor.js

@@ -0,0 +1,51 @@
+import { readFileSync } from 'node:fs';
+import { version as nodeVersion } from 'node:process';
+import { resolveConfig } from '../utils/config.js';
+import { runApiRequest } from '../utils/api-request.js';
+import { output } from '../utils/output.js';
+import { handleError } from '../utils/errors.js';
+const packageJson = JSON.parse(readFileSync(new URL('../../package.json', import.meta.url), 'utf8'));
+export function registerDoctorCommand(yargs) {
+    return yargs.command('doctor', 'Show redacted CLI configuration and optional connection status', (y) => y.option('connection', {
+        type: 'boolean',
+        describe: 'Call the user endpoint to verify API connectivity',
+        default: false,
+    }), async (argv) => {
+        try {
+            const resolved = resolveConfig();
+            const report = {
+                cli: {
+                    name: packageJson.name,
+                    version: packageJson.version,
+                    node: nodeVersion,
+                },
+                config: {
+                    apiKey: {
+                        resolved: Boolean(resolved.config.apiKey),
+                        source: resolved.sources.apiKey,
+                    },
+                    baseUrl: {
+                        value: resolved.config.baseUrl || 'https://zernio.com/api',
+                        source: resolved.sources.baseUrl || 'default',
+                    },
+                },
+            };
+            if (argv.connection) {
+                const result = await runApiRequest({ method: 'GET', path: '/v1/users' });
+                report.connection = {
+                    ok: result.ok,
+                    status: result.status,
+                    rateLimit: result.rateLimit,
+                };
+                output(report, argv.pretty);
+                if (!result.ok)
+                    process.exit(1);
+                return;
+            }
+            output(report, argv.pretty);
+        }
+        catch (err) {
+            handleError(err);
+        }
+    });
+}

package/dist/commands/inbox.d.ts

@@ -0,0 +1,6 @@
+import type { Argv } from 'yargs';
+/**
+ * Register inbox commands: conversations, messages, comments, and reviews.
+ * Uses the SDK's messages, comments, and reviews namespaces.
+ */
+export declare function registerInboxCommands(yargs: Argv): Argv;

package/dist/commands/inbox.js

@@ -0,0 +1,222 @@
+import { createClient } from '../client.js';
+import { output } from '../utils/output.js';
+import { handleError } from '../utils/errors.js';
+/**
+ * Register inbox commands: conversations, messages, comments, and reviews.
+ * Uses the SDK's messages, comments, and reviews namespaces.
+ */
+export function registerInboxCommands(yargs) {
+    return yargs
+        .command('inbox:conversations', 'List DM conversations', (y) => y
+        .option('profileId', { type: 'string', describe: 'Filter by profile ID' })
+        .option('accountId', { type: 'string', describe: 'Filter by account ID' })
+        .option('platform', { type: 'string', describe: 'Filter by platform (facebook, instagram, twitter, bluesky, reddit, telegram)' })
+        .option('status', { type: 'string', describe: 'Filter by status (active, archived)' })
+        .option('sortOrder', { type: 'string', describe: 'Sort order (asc, desc)', default: 'desc' })
+        .option('limit', { type: 'number', describe: 'Max results', default: 20 })
+        .option('cursor', { type: 'string', describe: 'Pagination cursor' }), async (argv) => {
+        try {
+            const late = createClient();
+            const query = {};
+            if (argv.profileId)
+                query.profileId = argv.profileId;
+            if (argv.accountId)
+                query.accountId = argv.accountId;
+            if (argv.platform)
+                query.platform = argv.platform;
+            if (argv.status)
+                query.status = argv.status;
+            if (argv.sortOrder)
+                query.sortOrder = argv.sortOrder;
+            if (argv.limit)
+                query.limit = argv.limit;
+            if (argv.cursor)
+                query.cursor = argv.cursor;
+            const { data } = await late.messages.listInboxConversations({ query });
+            output(data, argv.pretty);
+        }
+        catch (err) {
+            handleError(err);
+        }
+    })
+        .command('inbox:conversation <id>', 'Get conversation details', (y) => y
+        .positional('id', { type: 'string', describe: 'Conversation ID', demandOption: true })
+        .option('accountId', { type: 'string', describe: 'Account ID', demandOption: true }), async (argv) => {
+        try {
+            const late = createClient();
+            const { data } = await late.messages.getInboxConversation({
+                path: { conversationId: argv.id },
+                query: { accountId: argv.accountId },
+            });
+            output(data, argv.pretty);
+        }
+        catch (err) {
+            handleError(err);
+        }
+    })
+        .command('inbox:messages <conversationId>', 'Get messages in a conversation', (y) => y
+        .positional('conversationId', { type: 'string', describe: 'Conversation ID', demandOption: true })
+        .option('accountId', { type: 'string', describe: 'Account ID', demandOption: true }), async (argv) => {
+        try {
+            const late = createClient();
+            const { data } = await late.messages.getInboxConversationMessages({
+                path: { conversationId: argv.conversationId },
+                query: { accountId: argv.accountId },
+            });
+            output(data, argv.pretty);
+        }
+        catch (err) {
+            handleError(err);
+        }
+    })
+        .command('inbox:send <conversationId>', 'Send a DM in a conversation', (y) => y
+        .positional('conversationId', { type: 'string', describe: 'Conversation ID', demandOption: true })
+        .option('accountId', { type: 'string', describe: 'Account ID', demandOption: true })
+        .option('message', { type: 'string', describe: 'Message text', demandOption: true })
+        .option('mediaUrl', { type: 'string', describe: 'Media attachment URL' }), async (argv) => {
+        try {
+            const late = createClient();
+            const body = {
+                accountId: argv.accountId,
+                message: argv.message,
+            };
+            if (argv.mediaUrl)
+                body.mediaUrl = argv.mediaUrl;
+            const { data } = await late.messages.sendInboxMessage({
+                path: { conversationId: argv.conversationId },
+                body: body,
+            });
+            output(data, argv.pretty);
+        }
+        catch (err) {
+            handleError(err);
+        }
+    })
+        .command('inbox:comments', 'List post comments across accounts', (y) => y
+        .option('profileId', { type: 'string', describe: 'Filter by profile ID' })
+        .option('accountId', { type: 'string', describe: 'Filter by account ID' })
+        .option('platform', { type: 'string', describe: 'Filter by platform' })
+        .option('since', { type: 'string', describe: 'Posts created after this date (ISO 8601)' })
+        .option('sortBy', { type: 'string', describe: 'Sort field (date, comments)', default: 'date' })
+        .option('limit', { type: 'number', describe: 'Max results', default: 20 })
+        .option('cursor', { type: 'string', describe: 'Pagination cursor' }), async (argv) => {
+        try {
+            const late = createClient();
+            const query = {};
+            if (argv.profileId)
+                query.profileId = argv.profileId;
+            if (argv.accountId)
+                query.accountId = argv.accountId;
+            if (argv.platform)
+                query.platform = argv.platform;
+            if (argv.since)
+                query.since = argv.since;
+            if (argv.sortBy)
+                query.sortBy = argv.sortBy;
+            if (argv.limit)
+                query.limit = argv.limit;
+            if (argv.cursor)
+                query.cursor = argv.cursor;
+            const { data } = await late.comments.listInboxComments({ query });
+            output(data, argv.pretty);
+        }
+        catch (err) {
+            handleError(err);
+        }
+    })
+        .command('inbox:post-comments <postId>', 'Get comments on a specific post', (y) => y
+        .positional('postId', { type: 'string', describe: 'Post ID', demandOption: true })
+        .option('accountId', { type: 'string', describe: 'Account ID', demandOption: true }), async (argv) => {
+        try {
+            const late = createClient();
+            const { data } = await late.comments.getInboxPostComments({
+                path: { postId: argv.postId },
+                query: { accountId: argv.accountId },
+            });
+            output(data, argv.pretty);
+        }
+        catch (err) {
+            handleError(err);
+        }
+    })
+        .command('inbox:reply <postId>', 'Reply to a comment on a post', (y) => y
+        .positional('postId', { type: 'string', describe: 'Post ID', demandOption: true })
+        .option('accountId', { type: 'string', describe: 'Account ID', demandOption: true })
+        .option('message', { type: 'string', describe: 'Reply text', demandOption: true })
+        .option('commentId', { type: 'string', describe: 'Reply to specific comment ID (optional)' }), async (argv) => {
+        try {
+            const late = createClient();
+            const body = {
+                accountId: argv.accountId,
+                message: argv.message,
+            };
+            if (argv.commentId)
+                body.commentId = argv.commentId;
+            const { data } = await late.comments.replyToInboxPost({
+                path: { postId: argv.postId },
+                body: body,
+            });
+            output(data, argv.pretty);
+        }
+        catch (err) {
+            handleError(err);
+        }
+    })
+        .command('inbox:reviews', 'List reviews across accounts', (y) => y
+        .option('profileId', { type: 'string', describe: 'Filter by profile ID' })
+        .option('accountId', { type: 'string', describe: 'Filter by account ID' })
+        .option('platform', { type: 'string', describe: 'Filter by platform (facebook, googlebusiness)' })
+        .option('hasReply', { type: 'boolean', describe: 'Filter by reply status' })
+        .option('minRating', { type: 'number', describe: 'Minimum rating' })
+        .option('maxRating', { type: 'number', describe: 'Maximum rating' })
+        .option('sortBy', { type: 'string', describe: 'Sort field (date, rating)', default: 'date' })
+        .option('sortOrder', { type: 'string', describe: 'Sort order (asc, desc)', default: 'desc' })
+        .option('limit', { type: 'number', describe: 'Max results', default: 20 })
+        .option('cursor', { type: 'string', describe: 'Pagination cursor' }), async (argv) => {
+        try {
+            const late = createClient();
+            const query = {};
+            if (argv.profileId)
+                query.profileId = argv.profileId;
+            if (argv.accountId)
+                query.accountId = argv.accountId;
+            if (argv.platform)
+                query.platform = argv.platform;
+            if (argv.hasReply !== undefined)
+                query.hasReply = argv.hasReply;
+            if (argv.minRating !== undefined)
+                query.minRating = argv.minRating;
+            if (argv.maxRating !== undefined)
+                query.maxRating = argv.maxRating;
+            if (argv.sortBy)
+                query.sortBy = argv.sortBy;
+            if (argv.sortOrder)
+                query.sortOrder = argv.sortOrder;
+            if (argv.limit)
+                query.limit = argv.limit;
+            if (argv.cursor)
+                query.cursor = argv.cursor;
+            const { data } = await late.reviews.listInboxReviews({ query });
+            output(data, argv.pretty);
+        }
+        catch (err) {
+            handleError(err);
+        }
+    })
+        .command('inbox:review-reply <reviewId>', 'Reply to a review', (y) => y
+        .positional('reviewId', { type: 'string', describe: 'Review ID', demandOption: true })
+        .option('accountId', { type: 'string', describe: 'Account ID', demandOption: true })
+        .option('message', { type: 'string', describe: 'Reply text', demandOption: true }), async (argv) => {
+        try {
+            const late = createClient();
+            const { data } = await late.reviews.replyToInboxReview({
+                path: { reviewId: argv.reviewId },
+                body: { accountId: argv.accountId, message: argv.message },
+            });
+            output(data, argv.pretty);
+        }
+        catch (err) {
+            handleError(err);
+        }
+    });
+}

package/dist/commands/media.d.ts

@@ -0,0 +1,3 @@
+import type { Argv } from 'yargs';
+/** Register media commands: media:upload */
+export declare function registerMediaCommands(yargs: Argv): Argv;

package/dist/commands/media.js

@@ -0,0 +1,76 @@
+import { readFileSync, statSync } from 'fs';
+import { basename } from 'path';
+import { createClient } from '../client.js';
+import { output, outputError } from '../utils/output.js';
+import { handleError } from '../utils/errors.js';
+/** Minimal MIME lookup for media types Late supports. */
+const MIME_MAP = {
+    '.jpg': 'image/jpeg',
+    '.jpeg': 'image/jpeg',
+    '.png': 'image/png',
+    '.webp': 'image/webp',
+    '.gif': 'image/gif',
+    '.mp4': 'video/mp4',
+    '.mov': 'video/quicktime',
+    '.avi': 'video/x-msvideo',
+    '.webm': 'video/webm',
+    '.m4v': 'video/x-m4v',
+    '.mpeg': 'video/mpeg',
+    '.pdf': 'application/pdf',
+};
+function getMimeType(filename) {
+    const ext = filename.slice(filename.lastIndexOf('.')).toLowerCase();
+    return MIME_MAP[ext] || 'application/octet-stream';
+}
+/** Register media commands: media:upload */
+export function registerMediaCommands(yargs) {
+    return yargs.command('media:upload <file>', 'Upload a media file (returns URL for use in posts)', (y) => y.positional('file', { type: 'string', describe: 'Path to media file', demandOption: true }), async (argv) => {
+        try {
+            const filePath = argv.file;
+            // Validate file exists
+            let stat;
+            try {
+                stat = statSync(filePath);
+            }
+            catch {
+                outputError(`File not found: ${filePath}`);
+            }
+            if (!stat.isFile()) {
+                outputError(`Not a file: ${filePath}`);
+            }
+            const fileName = basename(filePath);
+            const contentType = getMimeType(fileName);
+            const fileBuffer = readFileSync(filePath);
+            // Get presigned URL via SDK
+            const late = createClient();
+            const { data: presign } = await late.media.getMediaPresignedUrl({
+                body: {
+                    filename: fileName,
+                    contentType,
+                    size: stat.size,
+                },
+            });
+            const presignData = presign;
+            // Upload file to presigned URL
+            const uploadRes = await fetch(presignData.uploadUrl, {
+                method: 'PUT',
+                headers: { 'Content-Type': contentType },
+                body: fileBuffer,
+            });
+            if (!uploadRes.ok) {
+                outputError(`Upload failed: ${uploadRes.statusText}`, uploadRes.status);
+            }
+            output({
+                success: true,
+                url: presignData.publicUrl,
+                key: presignData.key,
+                filename: fileName,
+                size: stat.size,
+                contentType,
+            }, argv.pretty);
+        }
+        catch (err) {
+            handleError(err);
+        }
+    });
+}

package/dist/commands/platforms.d.ts

@@ -0,0 +1,2 @@
+import type { Argv } from 'yargs';
+export declare function registerPlatformCommands(yargs: Argv): Argv;

package/dist/commands/platforms.js

@@ -0,0 +1,27 @@
+import { output } from '../utils/output.js';
+const platforms = [
+    'twitter',
+    'instagram',
+    'facebook',
+    'linkedin',
+    'tiktok',
+    'youtube',
+    'pinterest',
+    'reddit',
+    'bluesky',
+    'threads',
+    'googlebusiness',
+    'telegram',
+    'snapchat',
+    'whatsapp',
+    'discord',
+];
+export function registerPlatformCommands(yargs) {
+    return yargs.command('platforms:list', 'List supported platform identifiers', (y) => y, (argv) => {
+        output({
+            platforms,
+            source: 'https://docs.zernio.com/platforms',
+            note: 'Use the docs page as source of truth for current platform capabilities and constraints.',
+        }, argv.pretty);
+    });
+}

package/dist/commands/posts.d.ts

@@ -0,0 +1,3 @@
+import type { Argv } from 'yargs';
+/** Register post commands: posts:create, posts:list, posts:get, posts:delete, posts:retry */
+export declare function registerPostCommands(yargs: Argv): Argv;