@agendapanda/cli 0.1.0 → 0.3.0

package/dist/src/commands/calendar.js

@@ -1,8 +1,9 @@
 import chalk from 'chalk';
-import { readFile } from 'fs/promises';
+import { readFile, writeFile } from 'fs/promises';
 import { createHash } from 'crypto';
 import { api, ApiError } from '../lib/api.js';
 import { getActiveProject } from '../lib/config.js';
+import { filenameFromPath, guessMimeTypeFromPath } from '../lib/media.js';
 import { initJsonMode, isJsonMode, outputJson, outputTable, outputError } from '../lib/output.js';
 function computeIdempotencyKey(projectId, connectionId, content, scheduledAt) {
     const normalized = [
@@ -18,12 +19,60 @@ function matchesExistingPost(post, connectionId, content, scheduledAt) {
         post.content.trim() === content.trim() &&
         new Date(post.scheduled_at).toISOString() === new Date(scheduledAt).toISOString());
 }
+function validateScheduleUtc(schedule, index) {
+    const trimmed = schedule.trim();
+    // Must end with Z
+    if (!/Z$/i.test(trimmed)) {
+        outputError(`Item ${index}: schedule must be UTC ISO 8601 ending with Z ` +
+            `(e.g. 2025-03-15T14:00:00Z). Got: "${trimmed}". ` +
+            `schedule is execution time in UTC; timezone is display metadata only.`, 'INVALID_SCHEDULE');
+        process.exit(1);
+    }
+    // Must parse to valid date
+    const parsed = new Date(trimmed);
+    if (isNaN(parsed.getTime())) {
+        outputError(`Item ${index}: invalid date "${trimmed}"`, 'INVALID_SCHEDULE');
+        process.exit(1);
+    }
+    return parsed.toISOString();
+}
+function validateTimezone(tz, index) {
+    try {
+        Intl.DateTimeFormat(undefined, { timeZone: tz });
+    }
+    catch {
+        outputError(`Item ${index}: invalid timezone "${tz}". Use IANA format (e.g. America/New_York).`, 'INVALID_TIMEZONE');
+        process.exit(1);
+    }
+}
+function isUrl(value) {
+    return /^https?:\/\//i.test(value);
+}
+async function resolveMediaFile(mediaPath) {
+    const mimeType = guessMimeTypeFromPath(mediaPath);
+    if (!mimeType) {
+        throw new Error(`Unsupported media extension for ${mediaPath}. Use jpg/jpeg/png/gif/webp/mp4/mov/webm/m4v.`);
+    }
+    const mediaData = await readFile(mediaPath);
+    const filename = filenameFromPath(mediaPath);
+    const blob = new Blob([mediaData], { type: mimeType });
+    const formData = new FormData();
+    formData.append('file', blob, filename);
+    const uploadResult = await api.upload('/api/media/upload', formData);
+    return uploadResult.url;
+}
+/** Resolve a media value to a URL: passthrough if already a URL, upload if file path. */
+async function resolveMedia(value) {
+    if (isUrl(value))
+        return value;
+    return resolveMediaFile(value);
+}
 export function registerCalendarCommands(program) {
     const calendar = program.command('calendar').description('Bulk content calendar operations');
     // ap calendar import
     calendar
         .command('import')
-        .description('Import a content calendar from a JSON file')
+        .description('Import a content calendar from a JSON file. schedule must be UTC ISO 8601 (Z suffix); timezone is display metadata only.')
         .requiredOption('--file <path>', 'Path to JSON file with posts array')
         .option('--project <id>', 'Override active project')
         .option('--dry-run', 'Show what would be created without actually creating')
@@ -58,6 +107,12 @@ export function registerCalendarCommands(program) {
                     outputError(`Item ${i}: requires content, connection, and schedule fields`, 'INVALID_ITEM');
                     process.exit(1);
                 }
+                // Strict UTC validation
+                items[i].schedule = validateScheduleUtc(item.schedule, i);
+                // Timezone validation if present
+                if (item.timezone) {
+                    validateTimezone(item.timezone, i);
+                }
             }
             // Compute idempotency keys
             const itemKeys = items.map((item) => ({
@@ -119,21 +174,16 @@ export function registerCalendarCommands(program) {
                 }
                 return;
             }
-            // Process: upload images and create posts sequentially
+            // Process: upload media and create posts sequentially
             let created = 0;
             let failed = 0;
             for (const item of toCreate) {
                 try {
-                    // Upload image if present
+                    // Upload media if present
                     let mediaUrl;
-                    if (item.image) {
-                        const imageData = await readFile(item.image);
-                        const filename = item.image.split('/').pop() || 'image';
-                        const blob = new Blob([imageData]);
-                        const formData = new FormData();
-                        formData.append('file', blob, filename);
-                        const uploadResult = await api.upload('/api/media/upload', formData);
-                        mediaUrl = uploadResult.url;
+                    const mediaPath = item.media || item.image || item.video;
+                    if (mediaPath) {
+                        mediaUrl = await resolveMedia(mediaPath);
                     }
                     const scheduledAt = new Date(item.schedule).toISOString();
                     const data = await api.post(`/api/projects/${projectId}/posts`, {
@@ -203,5 +253,646 @@ export function registerCalendarCommands(program) {
             process.exit(1);
         }
     });
+    // ap calendar sync
+    calendar
+        .command('sync')
+        .description('Sync a calendar file with existing posts. Creates, updates, and optionally deletes posts by external_id. schedule must be UTC ISO 8601 (Z suffix); timezone is display metadata only.')
+        .requiredOption('--file <path>', 'Path to JSON file with CalendarItem[] (each must have external_id)')
+        .option('--project <id>', 'Override active project')
+        .option('--delete-missing', 'Delete unposted calendar_sync posts whose external_id is not in the file')
+        .option('--dry-run', 'Show what would happen without making changes')
+        .option('--json', 'Output as JSON')
+        .action(async (options) => {
+        initJsonMode(options);
+        try {
+            // Resolve project
+            const projectId = options.project || getActiveProject();
+            if (!projectId) {
+                outputError('No project set. Use --project, AP_PROJECT env, or `ap projects use <id>`.', 'MISSING_PROJECT');
+                process.exit(1);
+            }
+            // Permission check — fetch project and verify editor+ role
+            let project;
+            try {
+                const data = await api.get(`/api/projects/${projectId}`);
+                project = data.project;
+            }
+            catch (err) {
+                if (err instanceof ApiError && err.statusCode === 403) {
+                    outputError("You don't have access to this workspace.", 'FORBIDDEN');
+                    process.exit(1);
+                }
+                throw err;
+            }
+            const editorRoles = ['owner', 'admin', 'editor'];
+            if (!editorRoles.includes(project.user_role)) {
+                outputError(`Sync requires editor+ role. Your role is "${project.user_role}". Ask a workspace admin to upgrade your access.`, 'INSUFFICIENT_ROLE');
+                process.exit(1);
+            }
+            // Read and parse file
+            let items;
+            try {
+                const raw = await readFile(options.file, 'utf8');
+                items = JSON.parse(raw);
+            }
+            catch (err) {
+                outputError(`Failed to read/parse ${options.file}: ${err}`, 'INVALID_FILE');
+                process.exit(1);
+            }
+            if (!Array.isArray(items) || items.length === 0) {
+                outputError('File must contain a non-empty JSON array of items', 'INVALID_FORMAT');
+                process.exit(1);
+            }
+            // Validate: require external_id on every item, strict UTC schedule, IANA timezone
+            const seenExternalIds = new Set();
+            for (let i = 0; i < items.length; i++) {
+                const item = items[i];
+                if (!item.content || !item.connection || !item.schedule) {
+                    outputError(`Item ${i}: requires content, connection, and schedule fields`, 'INVALID_ITEM');
+                    process.exit(1);
+                }
+                if (!item.external_id) {
+                    outputError(`Item ${i}: external_id is required for sync`, 'MISSING_EXTERNAL_ID');
+                    process.exit(1);
+                }
+                if (seenExternalIds.has(item.external_id)) {
+                    outputError(`Duplicate external_id "${item.external_id}" in file`, 'DUPLICATE_EXTERNAL_ID');
+                    process.exit(1);
+                }
+                seenExternalIds.add(item.external_id);
+                items[i].schedule = validateScheduleUtc(item.schedule, i);
+                if (item.timezone) {
+                    validateTimezone(item.timezone, i);
+                }
+            }
+            // Fetch existing posts by external_ids
+            const externalIds = items.map((it) => it.external_id);
+            const existingData = await api.post(`/api/projects/${projectId}/posts/by-external-ids`, { external_ids: externalIds });
+            const existingPosts = existingData.posts || [];
+            const existingByExternalId = new Map();
+            for (const p of existingPosts) {
+                if (p.external_id)
+                    existingByExternalId.set(p.external_id, p);
+            }
+            // Classify each item
+            const results = [];
+            const toCreate = [];
+            const toUpdate = [];
+            // Connection changes require delete+recreate (PUT can't change connection/platform)
+            const toReplace = [];
+            for (const item of items) {
+                const eid = item.external_id;
+                const existing = existingByExternalId.get(eid);
+                if (!existing) {
+                    toCreate.push(item);
+                }
+                else if (existing.posted) {
+                    results.push({
+                        status: 'skipped_published',
+                        external_id: eid,
+                        content: item.content.slice(0, 50),
+                        connection: item.connection,
+                        schedule: item.schedule,
+                    });
+                }
+                else {
+                    const connectionMatch = existing.social_connection_id === item.connection;
+                    if (!connectionMatch) {
+                        // Connection changed — must delete + recreate
+                        toReplace.push({ item, existing });
+                    }
+                    else {
+                        // Check if content/schedule/media changed
+                        const scheduleMatch = new Date(existing.scheduled_at).toISOString() === new Date(item.schedule).toISOString();
+                        const contentMatch = existing.content.trim() === item.content.trim();
+                        // Media comparison:
+                        // - both null → match
+                        // - one null, other not → changed
+                        // - both URLs → direct string comparison
+                        // - file path vs URL → can't verify equality, assume changed
+                        //   (causes reupload on every sync for file-path items, but
+                        //   never silently drops media changes; use URLs to avoid this)
+                        const itemMedia = item.media || item.image || item.video || null;
+                        const itemMediaIsUrl = itemMedia !== null && /^https?:\/\//i.test(itemMedia);
+                        let mediaMatch;
+                        if (itemMedia === null) {
+                            mediaMatch = (existing.media_url || null) === null;
+                        }
+                        else if (itemMediaIsUrl) {
+                            mediaMatch = itemMedia === (existing.media_url || null);
+                        }
+                        else {
+                            // File path — can't compare to stored URL, assume changed
+                            mediaMatch = false;
+                        }
+                        if (contentMatch && scheduleMatch && mediaMatch) {
+                            results.push({
+                                status: 'unchanged',
+                                external_id: eid,
+                                content: item.content.slice(0, 50),
+                                connection: item.connection,
+                                schedule: item.schedule,
+                                post: existing,
+                            });
+                        }
+                        else {
+                            toUpdate.push({ item, existing });
+                        }
+                    }
+                }
+            }
+            // Identify posts to delete (if --delete-missing)
+            const toDelete = [];
+            if (options.deleteMissing) {
+                // Fetch all project posts to find calendar_sync posts not in file
+                const allPostsData = await api.get(`/api/projects/${projectId}/posts`);
+                const allPosts = allPostsData.posts || [];
+                for (const p of allPosts) {
+                    if (p.external_id &&
+                        p.source === 'calendar_sync' &&
+                        !p.posted &&
+                        !seenExternalIds.has(p.external_id)) {
+                        toDelete.push(p);
+                    }
+                }
+            }
+            // Dry run
+            if (options.dryRun) {
+                const dryResults = [
+                    ...results,
+                    ...toCreate.map((item) => ({
+                        status: 'created',
+                        external_id: item.external_id,
+                        content: item.content.slice(0, 50),
+                        connection: item.connection,
+                        schedule: item.schedule,
+                    })),
+                    ...toReplace.map(({ item }) => ({
+                        status: 'updated',
+                        external_id: item.external_id,
+                        content: item.content.slice(0, 50),
+                        connection: item.connection,
+                        schedule: item.schedule,
+                    })),
+                    ...toUpdate.map(({ item }) => ({
+                        status: 'updated',
+                        external_id: item.external_id,
+                        content: item.content.slice(0, 50),
+                        connection: item.connection,
+                        schedule: item.schedule,
+                    })),
+                    ...toDelete.map((p) => ({
+                        status: 'deleted',
+                        external_id: p.external_id,
+                        content: p.content.slice(0, 50),
+                        connection: p.social_connection_id || '',
+                        schedule: p.scheduled_at,
+                    })),
+                ];
+                const counts = {
+                    created: toCreate.length,
+                    updated: toUpdate.length + toReplace.length,
+                    deleted: toDelete.length,
+                    unchanged: results.filter((r) => r.status === 'unchanged').length,
+                    skipped_published: results.filter((r) => r.status === 'skipped_published').length,
+                };
+                if (isJsonMode(options)) {
+                    outputJson({ dry_run: true, ...counts, items: dryResults });
+                }
+                else {
+                    console.log(chalk.bold('Dry run results:'));
+                    console.log(`  Would create:  ${chalk.green(String(counts.created))}`);
+                    console.log(`  Would update:  ${chalk.blue(String(counts.updated))}`);
+                    console.log(`  Would delete:  ${chalk.red(String(counts.deleted))}`);
+                    console.log(`  Unchanged:     ${chalk.dim(String(counts.unchanged))}`);
+                    console.log(`  Skip (posted): ${chalk.yellow(String(counts.skipped_published))}`);
+                    if (dryResults.length > 0) {
+                        console.log('');
+                        outputTable(['ACTION', 'EXTERNAL_ID', 'CONTENT', 'SCHEDULE'], dryResults.map((r) => [
+                            r.status === 'created' ? chalk.green('create') :
+                                r.status === 'updated' ? chalk.blue('update') :
+                                    r.status === 'deleted' ? chalk.red('delete') :
+                                        r.status === 'skipped_published' ? chalk.yellow('skip') :
+                                            chalk.dim('unchanged'),
+                            r.external_id,
+                            r.content.length > 30 ? r.content.slice(0, 27) + '...' : r.content,
+                            r.schedule,
+                        ]));
+                    }
+                }
+                return;
+            }
+            // Execute sync
+            let createdCount = 0;
+            let updatedCount = 0;
+            let deletedCount = 0;
+            let failedCount = 0;
+            const total = toCreate.length + toReplace.length + toUpdate.length + toDelete.length;
+            let processed = 0;
+            // Creates
+            for (const item of toCreate) {
+                let mediaUrl;
+                const mediaPath = item.media || item.image || item.video;
+                try {
+                    if (mediaPath) {
+                        mediaUrl = await resolveMedia(mediaPath);
+                    }
+                    const createPayload = {
+                        content: item.content,
+                        scheduled_at: new Date(item.schedule).toISOString(),
+                        social_connection_id: item.connection,
+                        media_url: mediaUrl,
+                        post_now: false,
+                        external_id: item.external_id,
+                        source: 'calendar_sync',
+                    };
+                    if (item.timezone) {
+                        createPayload.timezone = item.timezone;
+                    }
+                    const data = await api.post(`/api/projects/${projectId}/posts`, createPayload);
+                    results.push({
+                        status: 'created',
+                        external_id: item.external_id,
+                        content: item.content.slice(0, 50),
+                        connection: item.connection,
+                        schedule: item.schedule,
+                        post: data.post,
+                    });
+                    createdCount++;
+                }
+                catch (err) {
+                    const msg = err instanceof ApiError ? err.message : String(err);
+                    // Race safety: unique constraint collision → try update
+                    if (msg.includes('UNIQUE constraint')) {
+                        try {
+                            // Re-fetch and update
+                            const refetch = await api.post(`/api/projects/${projectId}/posts/by-external-ids`, { external_ids: [item.external_id] });
+                            const existing = refetch.posts?.[0];
+                            if (existing) {
+                                const retryPayload = {
+                                    content: item.content,
+                                    scheduled_at: new Date(item.schedule).toISOString(),
+                                    last_synced_at: new Date().toISOString(),
+                                    source: 'calendar_sync',
+                                };
+                                if (item.timezone)
+                                    retryPayload.timezone = item.timezone;
+                                if (mediaUrl !== undefined)
+                                    retryPayload.media_url = mediaUrl;
+                                await api.put(`/api/posts/${existing.id}`, retryPayload);
+                                results.push({
+                                    status: 'updated',
+                                    external_id: item.external_id,
+                                    content: item.content.slice(0, 50),
+                                    connection: item.connection,
+                                    schedule: item.schedule,
+                                });
+                                updatedCount++;
+                            }
+                            else {
+                                throw new Error(msg);
+                            }
+                        }
+                        catch (retryErr) {
+                            const retryMsg = retryErr instanceof ApiError ? retryErr.message : String(retryErr);
+                            results.push({
+                                status: 'failed',
+                                external_id: item.external_id,
+                                content: item.content.slice(0, 50),
+                                connection: item.connection,
+                                schedule: item.schedule,
+                                error: retryMsg,
+                            });
+                            failedCount++;
+                        }
+                    }
+                    else {
+                        results.push({
+                            status: 'failed',
+                            external_id: item.external_id,
+                            content: item.content.slice(0, 50),
+                            connection: item.connection,
+                            schedule: item.schedule,
+                            error: msg,
+                        });
+                        failedCount++;
+                    }
+                }
+                processed++;
+                if (process.stdout.isTTY) {
+                    process.stdout.write(`\r  Syncing: ${processed}/${total}`);
+                }
+            }
+            // Replacements (connection changed → create new, then delete old)
+            // Create-first ordering: if create fails, old post is preserved.
+            for (const { item, existing } of toReplace) {
+                try {
+                    // Upload media if present (before any mutations)
+                    let replaceMediaUrl;
+                    const replaceMediaPath = item.media || item.image || item.video;
+                    if (replaceMediaPath) {
+                        replaceMediaUrl = await resolveMedia(replaceMediaPath);
+                    }
+                    // 1. Clear external_id on old post so unique constraint won't block create
+                    await api.put(`/api/posts/${existing.id}`, { external_id: null });
+                    // 2. Create new post with the external_id
+                    let newPost;
+                    try {
+                        const replacePayload = {
+                            content: item.content,
+                            scheduled_at: new Date(item.schedule).toISOString(),
+                            social_connection_id: item.connection,
+                            media_url: replaceMediaUrl,
+                            post_now: false,
+                            external_id: item.external_id,
+                            source: 'calendar_sync',
+                        };
+                        if (item.timezone) {
+                            replacePayload.timezone = item.timezone;
+                        }
+                        const data = await api.post(`/api/projects/${projectId}/posts`, replacePayload);
+                        newPost = data.post;
+                    }
+                    catch (createErr) {
+                        // Restore external_id on old post so sync identity stays intact
+                        try {
+                            await api.put(`/api/posts/${existing.id}`, { external_id: item.external_id });
+                        }
+                        catch { /* best-effort restore */ }
+                        throw createErr;
+                    }
+                    // 3. Delete old post (safe — new one already exists)
+                    let orphanWarning;
+                    try {
+                        await api.delete(`/api/posts/${existing.id}`);
+                    }
+                    catch {
+                        // Delete failed — old post is orphaned without external_id.
+                        // Restore its external_id with a prefix so --delete-missing can
+                        // still target it, and it won't collide with the new post's id.
+                        orphanWarning = `Old post ${existing.id} could not be deleted and is now orphaned. Run sync with --delete-missing to clean up.`;
+                        try {
+                            await api.put(`/api/posts/${existing.id}`, {
+                                external_id: `_orphan:${item.external_id}`,
+                                source: 'calendar_sync',
+                            });
+                        }
+                        catch { /* best-effort */ }
+                        if (process.stderr.isTTY) {
+                            console.error(chalk.yellow('Warning:') + ` ${orphanWarning}`);
+                        }
+                    }
+                    results.push({
+                        status: 'updated',
+                        external_id: item.external_id,
+                        content: item.content.slice(0, 50),
+                        connection: item.connection,
+                        schedule: item.schedule,
+                        post: newPost,
+                        error: orphanWarning,
+                    });
+                    updatedCount++;
+                }
+                catch (err) {
+                    const msg = err instanceof ApiError ? err.message : String(err);
+                    results.push({
+                        status: 'failed',
+                        external_id: item.external_id,
+                        content: item.content.slice(0, 50),
+                        connection: item.connection,
+                        schedule: item.schedule,
+                        error: msg,
+                    });
+                    failedCount++;
+                }
+                processed++;
+                if (process.stdout.isTTY) {
+                    process.stdout.write(`\r  Syncing: ${processed}/${total}`);
+                }
+            }
+            // Updates (same connection, content/schedule/media changed)
+            for (const { item, existing } of toUpdate) {
+                try {
+                    // Upload media only for new file paths or URL changes
+                    let mediaUrl;
+                    const mediaPath = item.media || item.image || item.video;
+                    if (!mediaPath && existing.media_url) {
+                        mediaUrl = null; // media removed
+                    }
+                    else if (mediaPath) {
+                        const isUrl = /^https?:\/\//i.test(mediaPath);
+                        if (isUrl && mediaPath !== existing.media_url) {
+                            // URL changed — send new URL directly
+                            mediaUrl = mediaPath;
+                        }
+                        else if (!isUrl) {
+                            // File path — upload it
+                            mediaUrl = await resolveMedia(mediaPath);
+                        }
+                        // else: same URL, no change
+                    }
+                    const updatePayload = {
+                        content: item.content,
+                        scheduled_at: new Date(item.schedule).toISOString(),
+                        last_synced_at: new Date().toISOString(),
+                        source: 'calendar_sync',
+                    };
+                    if (mediaUrl !== undefined) {
+                        updatePayload.media_url = mediaUrl;
+                    }
+                    if (item.timezone) {
+                        updatePayload.timezone = item.timezone;
+                    }
+                    await api.put(`/api/posts/${existing.id}`, updatePayload);
+                    results.push({
+                        status: 'updated',
+                        external_id: item.external_id,
+                        content: item.content.slice(0, 50),
+                        connection: item.connection,
+                        schedule: item.schedule,
+                    });
+                    updatedCount++;
+                }
+                catch (err) {
+                    const msg = err instanceof ApiError ? err.message : String(err);
+                    results.push({
+                        status: 'failed',
+                        external_id: item.external_id,
+                        content: item.content.slice(0, 50),
+                        connection: item.connection,
+                        schedule: item.schedule,
+                        error: msg,
+                    });
+                    failedCount++;
+                }
+                processed++;
+                if (process.stdout.isTTY) {
+                    process.stdout.write(`\r  Syncing: ${processed}/${total}`);
+                }
+            }
+            // Deletes
+            for (const post of toDelete) {
+                try {
+                    await api.delete(`/api/posts/${post.id}`);
+                    results.push({
+                        status: 'deleted',
+                        external_id: post.external_id,
+                        content: post.content.slice(0, 50),
+                        connection: post.social_connection_id || '',
+                        schedule: post.scheduled_at,
+                    });
+                    deletedCount++;
+                }
+                catch (err) {
+                    const msg = err instanceof ApiError ? err.message : String(err);
+                    results.push({
+                        status: 'failed',
+                        external_id: post.external_id,
+                        content: post.content.slice(0, 50),
+                        connection: post.social_connection_id || '',
+                        schedule: post.scheduled_at,
+                        error: msg,
+                    });
+                    failedCount++;
+                }
+                processed++;
+                if (process.stdout.isTTY) {
+                    process.stdout.write(`\r  Syncing: ${processed}/${total}`);
+                }
+            }
+            if (process.stdout.isTTY && total > 0) {
+                process.stdout.write('\n');
+            }
+            const unchangedCount = results.filter((r) => r.status === 'unchanged').length;
+            const skippedPublishedCount = results.filter((r) => r.status === 'skipped_published').length;
+            if (isJsonMode(options)) {
+                outputJson({
+                    success: failedCount === 0,
+                    created: createdCount,
+                    updated: updatedCount,
+                    deleted: deletedCount,
+                    unchanged: unchangedCount,
+                    skipped_published: skippedPublishedCount,
+                    failed: failedCount,
+                    items: results,
+                });
+            }
+            else {
+                console.log('');
+                console.log(chalk.bold('Calendar sync complete:'));
+                console.log(`  Created:  ${chalk.green(String(createdCount))}`);
+                console.log(`  Updated:  ${chalk.blue(String(updatedCount))}`);
+                console.log(`  Deleted:  ${chalk.red(String(deletedCount))}`);
+                console.log(`  Unchanged: ${chalk.dim(String(unchangedCount))}`);
+                console.log(`  Skipped:  ${chalk.yellow(String(skippedPublishedCount))} (already published)`);
+                if (failedCount > 0) {
+                    console.log(`  Failed:   ${chalk.red(String(failedCount))}`);
+                }
+            }
+            if (failedCount > 0) {
+                process.exit(1);
+            }
+        }
+        catch (err) {
+            if (err instanceof ApiError) {
+                outputError(err.message, err.code);
+            }
+            else {
+                outputError(String(err));
+            }
+            process.exit(1);
+        }
+    });
+    // ap calendar pull
+    calendar
+        .command('pull')
+        .description('Pull scheduled posts from the server as a CalendarItem JSON array. Use with sync for round-trip editing.')
+        .option('--file <path>', 'Write output to file instead of stdout')
+        .option('--project <id>', 'Override active project')
+        .option('--include-published', 'Include already-published posts (excluded by default)')
+        .option('--from <date>', 'Only include posts scheduled on or after this date (ISO 8601)')
+        .option('--to <date>', 'Only include posts scheduled on or before this date (ISO 8601)')
+        .option('--json', 'Output as JSON (default when piped)')
+        .action(async (options) => {
+        initJsonMode(options);
+        try {
+            const projectId = options.project || getActiveProject();
+            if (!projectId) {
+                outputError('No project set. Use --project, AP_PROJECT env, or `ap projects use <id>`.', 'MISSING_PROJECT');
+                process.exit(1);
+            }
+            // Validate date filters
+            let fromDate = null;
+            let toDate = null;
+            if (options.from) {
+                fromDate = new Date(options.from);
+                if (isNaN(fromDate.getTime())) {
+                    outputError(`Invalid --from date: "${options.from}"`, 'INVALID_DATE');
+                    process.exit(1);
+                }
+            }
+            if (options.to) {
+                toDate = new Date(options.to);
+                if (isNaN(toDate.getTime())) {
+                    outputError(`Invalid --to date: "${options.to}"`, 'INVALID_DATE');
+                    process.exit(1);
+                }
+            }
+            // Fetch posts
+            const data = await api.get(`/api/projects/${projectId}/posts`);
+            let posts = data.posts || [];
+            // Filter: exclude published by default
+            if (!options.includePublished) {
+                posts = posts.filter((p) => !p.posted);
+            }
+            // Filter by date range
+            if (fromDate) {
+                const fromMs = fromDate.getTime();
+                posts = posts.filter((p) => new Date(p.scheduled_at).getTime() >= fromMs);
+            }
+            if (toDate) {
+                const toMs = toDate.getTime();
+                posts = posts.filter((p) => new Date(p.scheduled_at).getTime() <= toMs);
+            }
+            // Map to CalendarItem format
+            const items = posts.map((p) => {
+                const item = {
+                    content: p.content,
+                    connection: p.social_connection_id || '',
+                    schedule: new Date(p.scheduled_at).toISOString(),
+                };
+                if (p.external_id) {
+                    item.external_id = p.external_id;
+                }
+                if (p.media_url) {
+                    item.media = p.media_url;
+                }
+                return item;
+            });
+            const output = JSON.stringify(items, null, 2);
+            if (options.file) {
+                await writeFile(options.file, output + '\n', 'utf8');
+                if (process.stderr.isTTY) {
+                    console.error(chalk.green(`Wrote ${items.length} post(s) to ${options.file}`));
+                }
+            }
+            else if (isJsonMode(options)) {
+                outputJson({ items, count: items.length });
+            }
+            else {
+                // Default: write raw array to stdout (ready for editing / piping to sync)
+                process.stdout.write(output + '\n');
+            }
+        }
+        catch (err) {
+            if (err instanceof ApiError) {
+                outputError(err.message, err.code);
+            }
+            else {
+                outputError(String(err));
+            }
+            process.exit(1);
+        }
+    });
 }
 //# sourceMappingURL=calendar.js.map