zernio-cli 0.4.0

package/dist/commands/posts.js

@@ -0,0 +1,129 @@
+import { createClient } from '../client.js';
+import { output, outputError } from '../utils/output.js';
+import { handleError } from '../utils/errors.js';
+/** Register post commands: posts:create, posts:list, posts:get, posts:delete, posts:retry */
+export function registerPostCommands(yargs) {
+    return yargs
+        .command('posts:create', 'Create or schedule a post', (y) => y
+        .option('text', { type: 'string', describe: 'Post content text', demandOption: true })
+        .option('accounts', { type: 'string', describe: 'Comma-separated account IDs', demandOption: true })
+        .option('scheduledAt', { type: 'string', describe: 'ISO 8601 date to schedule (omit to publish now)' })
+        .option('draft', { type: 'boolean', describe: 'Save as draft', default: false })
+        .option('media', { type: 'string', describe: 'Comma-separated media URLs' })
+        .option('title', { type: 'string', describe: 'Post title (YouTube, Reddit, etc.)' })
+        .option('tags', { type: 'string', describe: 'Comma-separated tags' })
+        .option('hashtags', { type: 'string', describe: 'Comma-separated hashtags' })
+        .option('timezone', { type: 'string', describe: 'Timezone (e.g. America/New_York)' }), async (argv) => {
+        try {
+            const late = createClient();
+            // Look up accounts to resolve platform types
+            const { data: accountsData } = await late.accounts.listAccounts();
+            const allAccounts = accountsData?.accounts || [];
+            const accountIds = argv.accounts.split(',').map((s) => s.trim()).filter(Boolean);
+            const platforms = accountIds.map((id) => {
+                const account = allAccounts.find((a) => (a._id || a.id) === id);
+                if (!account) {
+                    outputError(`Account ${id} not found. Run "late accounts:list" to see available accounts.`, 404);
+                }
+                return { platform: account.platform, accountId: id };
+            });
+            // Build media items
+            const mediaItems = argv.media
+                ? argv.media.split(',').map((url) => {
+                    const trimmed = url.trim();
+                    const isVideo = /\.(mp4|mov|avi|webm|m4v)$/i.test(trimmed);
+                    return { type: (isVideo ? 'video' : 'image'), url: trimmed };
+                })
+                : undefined;
+            const body = {
+                content: argv.text,
+                platforms,
+            };
+            if (mediaItems?.length)
+                body.mediaItems = mediaItems;
+            if (argv.title)
+                body.title = argv.title;
+            if (argv.timezone)
+                body.timezone = argv.timezone;
+            if (argv.tags)
+                body.tags = argv.tags.split(',').map((s) => s.trim());
+            if (argv.hashtags)
+                body.hashtags = argv.hashtags.split(',').map((s) => s.trim());
+            if (argv.draft) {
+                body.isDraft = true;
+            }
+            else if (argv.scheduledAt) {
+                body.scheduledFor = argv.scheduledAt;
+            }
+            else {
+                body.publishNow = true;
+            }
+            const { data } = await late.posts.createPost({ body });
+            output(data, argv.pretty);
+        }
+        catch (err) {
+            handleError(err);
+        }
+    })
+        .command('posts:list', 'List posts', (y) => y
+        .option('profileId', { type: 'string', describe: 'Filter by profile ID' })
+        .option('status', { type: 'string', describe: 'Filter by status (scheduled, published, failed, draft)' })
+        .option('platform', { type: 'string', describe: 'Filter by platform' })
+        .option('from', { type: 'string', describe: 'Start date (ISO 8601)' })
+        .option('to', { type: 'string', describe: 'End date (ISO 8601)' })
+        .option('page', { type: 'number', describe: 'Page number', default: 1 })
+        .option('limit', { type: 'number', describe: 'Results per page', default: 10 }), async (argv) => {
+        try {
+            const late = createClient();
+            const query = {
+                page: argv.page,
+                limit: argv.limit,
+            };
+            if (argv.profileId)
+                query.profileId = argv.profileId;
+            if (argv.status)
+                query.status = argv.status;
+            if (argv.platform)
+                query.platform = argv.platform;
+            if (argv.from)
+                query.dateFrom = argv.from;
+            if (argv.to)
+                query.dateTo = argv.to;
+            const { data } = await late.posts.listPosts({ query });
+            output(data, argv.pretty);
+        }
+        catch (err) {
+            handleError(err);
+        }
+    })
+        .command('posts:get <id>', 'Get post details', (y) => y.positional('id', { type: 'string', describe: 'Post ID', demandOption: true }), async (argv) => {
+        try {
+            const late = createClient();
+            const { data } = await late.posts.getPost({ path: { postId: argv.id } });
+            output(data, argv.pretty);
+        }
+        catch (err) {
+            handleError(err);
+        }
+    })
+        .command('posts:delete <id>', 'Delete a post', (y) => y.positional('id', { type: 'string', describe: 'Post ID', demandOption: true }), async (argv) => {
+        try {
+            const late = createClient();
+            const { data } = await late.posts.deletePost({ path: { postId: argv.id } });
+            output(data, argv.pretty);
+        }
+        catch (err) {
+            handleError(err);
+        }
+    })
+        .command('posts:retry <id>', 'Retry a failed post', (y) => y.positional('id', { type: 'string', describe: 'Post ID', demandOption: true }), async (argv) => {
+        try {
+            const late = createClient();
+            const { data } = await late.posts.retryPost({ path: { postId: argv.id } });
+            output(data, argv.pretty);
+        }
+        catch (err) {
+            handleError(err);
+        }
+    });
+}

package/dist/commands/profiles.d.ts

@@ -0,0 +1,3 @@
+import type { Argv } from 'yargs';
+/** Register profile commands: profiles:list, profiles:create, profiles:get, profiles:update, profiles:delete */
+export declare function registerProfileCommands(yargs: Argv): Argv;

package/dist/commands/profiles.js

@@ -0,0 +1,82 @@
+import { createClient } from '../client.js';
+import { output } from '../utils/output.js';
+import { handleError } from '../utils/errors.js';
+/** Register profile commands: profiles:list, profiles:create, profiles:get, profiles:update, profiles:delete */
+export function registerProfileCommands(yargs) {
+    return yargs
+        .command('profiles:list', 'List all profiles', (y) => y, async (argv) => {
+        try {
+            const late = createClient();
+            const { data } = await late.profiles.listProfiles();
+            output(data, argv.pretty);
+        }
+        catch (err) {
+            handleError(err);
+        }
+    })
+        .command('profiles:create', 'Create a new profile', (y) => y
+        .option('name', { type: 'string', describe: 'Profile name', demandOption: true })
+        .option('description', { type: 'string', describe: 'Profile description' })
+        .option('color', { type: 'string', describe: 'Profile color' }), async (argv) => {
+        try {
+            const late = createClient();
+            const body = { name: argv.name };
+            if (argv.description)
+                body.description = argv.description;
+            if (argv.color)
+                body.color = argv.color;
+            const { data } = await late.profiles.createProfile({ body });
+            output(data, argv.pretty);
+        }
+        catch (err) {
+            handleError(err);
+        }
+    })
+        .command('profiles:get <id>', 'Get profile details', (y) => y.positional('id', { type: 'string', describe: 'Profile ID', demandOption: true }), async (argv) => {
+        try {
+            const late = createClient();
+            const { data } = await late.profiles.getProfile({ path: { profileId: argv.id } });
+            output(data, argv.pretty);
+        }
+        catch (err) {
+            handleError(err);
+        }
+    })
+        .command('profiles:update <id>', 'Update a profile', (y) => y
+        .positional('id', { type: 'string', describe: 'Profile ID', demandOption: true })
+        .option('name', { type: 'string', describe: 'New name' })
+        .option('description', { type: 'string', describe: 'New description' })
+        .option('color', { type: 'string', describe: 'New color' })
+        .option('isDefault', { type: 'boolean', describe: 'Set as default profile' }), async (argv) => {
+        try {
+            const late = createClient();
+            const body = {};
+            if (argv.name !== undefined)
+                body.name = argv.name;
+            if (argv.description !== undefined)
+                body.description = argv.description;
+            if (argv.color !== undefined)
+                body.color = argv.color;
+            if (argv.isDefault !== undefined)
+                body.isDefault = argv.isDefault;
+            const { data } = await late.profiles.updateProfile({
+                path: { profileId: argv.id },
+                body: body,
+            });
+            output(data, argv.pretty);
+        }
+        catch (err) {
+            handleError(err);
+        }
+    })
+        .command('profiles:delete <id>', 'Delete a profile', (y) => y.positional('id', { type: 'string', describe: 'Profile ID', demandOption: true }), async (argv) => {
+        try {
+            const late = createClient();
+            const { data } = await late.profiles.deleteProfile({ path: { profileId: argv.id } });
+            output(data, argv.pretty);
+        }
+        catch (err) {
+            handleError(err);
+        }
+    });
+}

package/dist/commands/sequences.d.ts

@@ -0,0 +1,5 @@
+import type { Argv } from 'yargs';
+/**
+ * Register sequence commands: CRUD, activate, pause, enroll, unenroll, enrollments.
+ */
+export declare function registerSequenceCommands(yargs: Argv): Argv;

package/dist/commands/sequences.js

@@ -0,0 +1,178 @@
+import { createClient } from '../client.js';
+import { output } from '../utils/output.js';
+import { handleError } from '../utils/errors.js';
+/**
+ * Register sequence commands: CRUD, activate, pause, enroll, unenroll, enrollments.
+ */
+export function registerSequenceCommands(yargs) {
+    return yargs
+        .command('sequences:list', 'List sequences', (y) => y
+        .option('profileId', { type: 'string', describe: 'Filter by profile ID' })
+        .option('status', { type: 'string', describe: 'Filter by status (draft, active, paused)' })
+        .option('limit', { type: 'number', describe: 'Max results', default: 20 })
+        .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.status)
+                query.status = argv.status;
+            const { data } = await late.sequences.listSequences({ query });
+            output(data, argv.pretty);
+        }
+        catch (err) {
+            handleError(err);
+        }
+    })
+        .command('sequences:create', 'Create a sequence', (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('name', { type: 'string', describe: 'Sequence name', demandOption: true })
+        .option('stepsFile', { type: 'string', describe: 'Path to JSON file with steps array' })
+        .option('exitOnReply', { type: 'boolean', describe: 'Exit sequence when contact replies', default: true })
+        .option('exitOnUnsubscribe', { type: 'boolean', describe: 'Exit sequence when contact unsubscribes', default: true }), async (argv) => {
+        try {
+            const late = createClient();
+            const body = {
+                profileId: argv.profileId,
+                accountId: argv.accountId,
+                platform: argv.platform,
+                name: argv.name,
+                exitOnReply: argv.exitOnReply,
+                exitOnUnsubscribe: argv.exitOnUnsubscribe,
+            };
+            // Steps can be provided via a JSON file for complex sequences
+            if (argv.stepsFile) {
+                const { readFileSync } = await import('fs');
+                const raw = readFileSync(argv.stepsFile, 'utf-8');
+                body.steps = JSON.parse(raw);
+            }
+            const { data } = await late.sequences.createSequence({ body: body });
+            output(data, argv.pretty);
+        }
+        catch (err) {
+            handleError(err);
+        }
+    })
+        .command('sequences:get <id>', 'Get sequence details with steps', (y) => y.positional('id', { type: 'string', describe: 'Sequence ID', demandOption: true }), async (argv) => {
+        try {
+            const late = createClient();
+            const { data } = await late.sequences.getSequence({ path: { sequenceId: argv.id } });
+            output(data, argv.pretty);
+        }
+        catch (err) {
+            handleError(err);
+        }
+    })
+        .command('sequences:update <id>', 'Update a sequence', (y) => y
+        .positional('id', { type: 'string', describe: 'Sequence ID', demandOption: true })
+        .option('name', { type: 'string', describe: 'Sequence name' })
+        .option('stepsFile', { type: 'string', describe: 'Path to JSON file with steps array' })
+        .option('exitOnReply', { type: 'boolean', describe: 'Exit on reply' })
+        .option('exitOnUnsubscribe', { type: 'boolean', describe: 'Exit on unsubscribe' }), async (argv) => {
+        try {
+            const late = createClient();
+            const { data } = await late.sequences.updateSequence({
+                path: { sequenceId: argv.id },
+            });
+            output(data, argv.pretty);
+        }
+        catch (err) {
+            handleError(err);
+        }
+    })
+        .command('sequences:delete <id>', 'Delete a sequence', (y) => y.positional('id', { type: 'string', describe: 'Sequence ID', demandOption: true }), async (argv) => {
+        try {
+            const late = createClient();
+            const { data } = await late.sequences.deleteSequence({ path: { sequenceId: argv.id } });
+            output(data, argv.pretty);
+        }
+        catch (err) {
+            handleError(err);
+        }
+    })
+        .command('sequences:activate <id>', 'Activate a sequence', (y) => y.positional('id', { type: 'string', describe: 'Sequence ID', demandOption: true }), async (argv) => {
+        try {
+            const late = createClient();
+            const { data } = await late.sequences.activateSequence({ path: { sequenceId: argv.id } });
+            output(data, argv.pretty);
+        }
+        catch (err) {
+            handleError(err);
+        }
+    })
+        .command('sequences:pause <id>', 'Pause a sequence', (y) => y.positional('id', { type: 'string', describe: 'Sequence ID', demandOption: true }), async (argv) => {
+        try {
+            const late = createClient();
+            const { data } = await late.sequences.pauseSequence({ path: { sequenceId: argv.id } });
+            output(data, argv.pretty);
+        }
+        catch (err) {
+            handleError(err);
+        }
+    })
+        .command('sequences:enroll <id>', 'Enroll contacts into a sequence', (y) => y
+        .positional('id', { type: 'string', describe: 'Sequence ID', demandOption: true })
+        .option('contactIds', { type: 'string', describe: 'Comma-separated contact IDs', demandOption: true })
+        .option('channelIds', { type: 'string', describe: 'Comma-separated channel IDs (optional, uses default channel per contact)' }), async (argv) => {
+        try {
+            const late = createClient();
+            const body = {
+                contactIds: argv.contactIds.split(',').map((s) => s.trim()),
+            };
+            if (argv.channelIds) {
+                body.channelIds = argv.channelIds.split(',').map((s) => s.trim());
+            }
+            const { data } = await late.sequences.enrollContacts({
+                path: { sequenceId: argv.id },
+                body: body,
+            });
+            output(data, argv.pretty);
+        }
+        catch (err) {
+            handleError(err);
+        }
+    })
+        .command('sequences:unenroll <id> <contactId>', 'Unenroll a contact from a sequence', (y) => y
+        .positional('id', { type: 'string', describe: 'Sequence ID', demandOption: true })
+        .positional('contactId', { type: 'string', describe: 'Contact ID', demandOption: true }), async (argv) => {
+        try {
+            const late = createClient();
+            const { data } = await late.sequences.unenrollContact({
+                path: { sequenceId: argv.id, contactId: argv.contactId },
+            });
+            output(data, argv.pretty);
+        }
+        catch (err) {
+            handleError(err);
+        }
+    })
+        .command('sequences:enrollments <id>', 'List enrollments for a sequence', (y) => y
+        .positional('id', { type: 'string', describe: 'Sequence ID', demandOption: true })
+        .option('status', { type: 'string', describe: 'Filter by status (active, completed, exited, paused)' })
+        .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.status)
+                query.status = argv.status;
+            const { data } = await late.sequences.listSequenceEnrollments({
+                path: { sequenceId: argv.id },
+                query,
+            });
+            output(data, argv.pretty);
+        }
+        catch (err) {
+            handleError(err);
+        }
+    });
+}