@myvillage/cli 1.8.4 → 1.9.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@myvillage/cli",
-  "version": "1.8.4",
+  "version": "1.9.0",
   "description": "MyVillageOS CLI for community developers",
   "type": "module",
   "bin": {

package/src/commands/media.js

@@ -0,0 +1,943 @@
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import { readFileSync, statSync, createReadStream } from 'fs';
+import { resolve, basename } from 'path';
+import axios from 'axios';
+import pLimit from 'p-limit';
+import { isAuthenticated } from '../utils/auth.js';
+import { brand, villageSpinner } from '../utils/brand.js';
+import {
+  createMediaDraft,
+  listMediaDrafts,
+  getMediaDraft,
+  getMediaDraftStatus,
+  updateMediaDraft,
+  uploadMediaDraftAsset,
+  getMediaDraftUploadUrl,
+  confirmMediaDraftUpload,
+} from '../utils/api.js';
+
+// ── Status badge colors ────────────────────────────────
+
+const STATUS_COLORS = {
+  DRAFT: chalk.gray,
+  SUBMITTED: chalk.cyan,
+  IN_REVIEW: chalk.yellow,
+  APPROVED: chalk.green,
+  REJECTED: chalk.red,
+  SCHEDULED: chalk.magenta,
+  PUBLISHED: chalk.greenBright,
+  CANCELLED: chalk.gray,
+};
+
+function statusBadge(status) {
+  const colorFn = STATUS_COLORS[status] || chalk.white;
+  return colorFn(status);
+}
+
+// ── Platform display names ─────────────────────────────
+
+const PLATFORM_LABELS = {
+  LINKEDIN: 'LinkedIn',
+  YOUTUBE: 'YouTube',
+  TIKTOK: 'TikTok',
+  INSTAGRAM: 'Instagram',
+};
+
+// ── Size thresholds ────────────────────────────────────
+
+// Files under this size use the simple buffered upload endpoint.
+// Files over this size use presigned URL (direct-to-S3) upload.
+const PRESIGNED_THRESHOLD = 5 * 1024 * 1024; // 5 MB
+
+// ── Content type detection ─────────────────────────────
+
+const CONTENT_TYPES = {
+  png: 'image/png', jpg: 'image/jpeg', jpeg: 'image/jpeg',
+  gif: 'image/gif', webp: 'image/webp', svg: 'image/svg+xml',
+  mp4: 'video/mp4', webm: 'video/webm', mov: 'video/quicktime',
+  avi: 'video/x-msvideo', mkv: 'video/x-matroska',
+  pdf: 'application/pdf',
+};
+
+function getContentType(fileName) {
+  const ext = fileName.split('.').pop()?.toLowerCase() || '';
+  return CONTENT_TYPES[ext] || 'application/octet-stream';
+}
+
+// ── Auto-detect asset type from file extension ─────────
+
+function inferAssetType(fileName) {
+  const ext = fileName.split('.').pop()?.toLowerCase() || '';
+  const imageExts = ['png', 'jpg', 'jpeg', 'gif', 'webp', 'svg'];
+  const videoExts = ['mp4', 'webm', 'mov', 'avi', 'mkv'];
+  const docExts = ['pdf'];
+
+  if (imageExts.includes(ext)) return 'IMAGE';
+  if (videoExts.includes(ext)) return 'VIDEO';
+  if (docExts.includes(ext)) return 'DOCUMENT';
+  return null;
+}
+
+// ── Platform-specific metadata prompts ─────────────────
+
+async function promptPlatformMetadata(platform, existing = {}) {
+  const prompts = [];
+
+  if (platform === 'YOUTUBE') {
+    prompts.push(
+      {
+        type: 'list',
+        name: 'privacy',
+        message: 'Privacy:',
+        choices: [
+          { name: 'Public', value: 'public' },
+          { name: 'Unlisted', value: 'unlisted' },
+          { name: 'Private', value: 'private' },
+        ],
+        default: existing.privacy || 'public',
+      },
+      {
+        type: 'list',
+        name: 'category',
+        message: 'Category:',
+        choices: [
+          { name: 'Education', value: 'Education' },
+          { name: 'Science & Technology', value: 'Science & Technology' },
+          { name: 'People & Blogs', value: 'People & Blogs' },
+          { name: 'Entertainment', value: 'Entertainment' },
+          { name: 'Howto & Style', value: 'Howto & Style' },
+          { name: 'Gaming', value: 'Gaming' },
+          { name: 'Nonprofits & Activism', value: 'Nonprofits & Activism' },
+        ],
+        default: existing.category || 'Education',
+      },
+      {
+        type: 'input',
+        name: 'language',
+        message: 'Language (e.g., en, es, fr):',
+        default: existing.language || 'en',
+      },
+    );
+  }
+
+  if (platform === 'LINKEDIN') {
+    prompts.push(
+      {
+        type: 'list',
+        name: 'visibility',
+        message: 'Visibility:',
+        choices: [
+          { name: 'Public (anyone)', value: 'PUBLIC' },
+          { name: 'Connections only', value: 'CONNECTIONS' },
+        ],
+        default: existing.visibility || 'PUBLIC',
+      },
+      {
+        type: 'list',
+        name: 'contentType',
+        message: 'Post type:',
+        choices: [
+          { name: 'Share / Status update', value: 'share' },
+          { name: 'Article', value: 'article' },
+        ],
+        default: existing.contentType || 'share',
+      },
+    );
+  }
+
+  if (platform === 'TIKTOK') {
+    prompts.push(
+      {
+        type: 'list',
+        name: 'privacy',
+        message: 'Privacy:',
+        choices: [
+          { name: 'Public', value: 'PUBLIC_TO_EVERYONE' },
+          { name: 'Friends only', value: 'MUTUAL_FOLLOW_FRIENDS' },
+          { name: 'Private (only me)', value: 'SELF_ONLY' },
+        ],
+        default: existing.privacy || 'PUBLIC_TO_EVERYONE',
+      },
+      {
+        type: 'confirm',
+        name: 'allowComments',
+        message: 'Allow comments?',
+        default: existing.allowComments !== undefined ? existing.allowComments : true,
+      },
+      {
+        type: 'confirm',
+        name: 'allowDuet',
+        message: 'Allow duets?',
+        default: existing.allowDuet !== undefined ? existing.allowDuet : true,
+      },
+      {
+        type: 'confirm',
+        name: 'allowStitch',
+        message: 'Allow stitches?',
+        default: existing.allowStitch !== undefined ? existing.allowStitch : true,
+      },
+      {
+        type: 'confirm',
+        name: 'brandedContent',
+        message: 'Is this branded content?',
+        default: existing.brandedContent || false,
+      },
+    );
+  }
+
+  if (platform === 'INSTAGRAM') {
+    prompts.push(
+      {
+        type: 'input',
+        name: 'altText',
+        message: 'Alt text for accessibility (optional):',
+        default: existing.altText || '',
+      },
+      {
+        type: 'input',
+        name: 'location',
+        message: 'Location tag (optional):',
+        default: existing.location || '',
+      },
+      {
+        type: 'input',
+        name: 'collaborators',
+        message: 'Collaborator handles (comma-separated, optional):',
+        default: existing.collaborators?.join(', ') || '',
+      },
+    );
+  }
+
+  if (prompts.length === 0) return null;
+
+  console.log(brand.teal(`\n  ${PLATFORM_LABELS[platform]} settings:\n`));
+  const answers = await inquirer.prompt(prompts);
+
+  // Clean up empty strings and parse collaborators
+  const metadata = {};
+  for (const [key, value] of Object.entries(answers)) {
+    if (value === '' || value === undefined) continue;
+    if (key === 'collaborators' && typeof value === 'string') {
+      const parsed = value.split(',').map(s => s.trim()).filter(Boolean);
+      if (parsed.length > 0) metadata[key] = parsed;
+    } else {
+      metadata[key] = value;
+    }
+  }
+
+  return Object.keys(metadata).length > 0 ? metadata : null;
+}
+
+// ── media draft create ─────────────────────────────────
+
+export async function mediaDraftCreateCommand(options = {}) {
+  if (!isAuthenticated()) {
+    console.log(chalk.red('  \u2717 Authentication required. Run \'myvillage login\' first.'));
+    return;
+  }
+
+  try {
+    console.log(`\n  ${brand.gold(chalk.bold('\u2726 Media Draft \u2014 New Submission'))}\n`);
+
+    // Platform selection
+    const platformAnswer = await inquirer.prompt([{
+      type: 'list',
+      name: 'platform',
+      message: 'Target platform:',
+      choices: [
+        { name: 'LinkedIn', value: 'LINKEDIN' },
+        { name: 'YouTube', value: 'YOUTUBE' },
+        { name: 'TikTok', value: 'TIKTOK' },
+        { name: 'Instagram', value: 'INSTAGRAM' },
+      ],
+    }]);
+
+    // Content fields based on platform
+    const isVideo = ['YOUTUBE', 'TIKTOK'].includes(platformAnswer.platform);
+
+    const contentPrompts = [];
+
+    if (platformAnswer.platform === 'YOUTUBE') {
+      contentPrompts.push({
+        type: 'input',
+        name: 'title',
+        message: 'Video title:',
+        validate: (v) => v.trim() ? true : 'Title is required for YouTube',
+      });
+    }
+
+    contentPrompts.push({
+      type: 'input',
+      name: 'caption',
+      message: isVideo ? 'Description / caption:' : 'Caption:',
+      validate: (v, answers) => {
+        if (v.trim()) return true;
+        if (answers?.title?.trim()) return true;
+        return 'Caption is required';
+      },
+    });
+
+    if (isVideo) {
+      contentPrompts.push({
+        type: 'input',
+        name: 'script',
+        message: 'Script (optional, press Enter to skip):',
+      });
+    }
+
+    contentPrompts.push({
+      type: 'input',
+      name: 'tags',
+      message: 'Tags / hashtags (comma-separated, optional):',
+    });
+
+    contentPrompts.push({
+      type: 'input',
+      name: 'suggestedPublishAt',
+      message: 'Suggested publish date (YYYY-MM-DD or YYYY-MM-DDTHH:mm, optional):',
+    });
+
+    const answers = await inquirer.prompt(contentPrompts);
+
+    // Platform-specific settings
+    const platformMetadata = await promptPlatformMetadata(platformAnswer.platform);
+
+    // Build draft payload
+    const data = {
+      platform: platformAnswer.platform,
+      intakeMethod: 'CLI',
+    };
+
+    if (answers.caption?.trim()) data.caption = answers.caption.trim();
+    if (answers.title?.trim()) data.title = answers.title.trim();
+    if (answers.script?.trim()) data.script = answers.script.trim();
+    if (answers.tags?.trim()) {
+      data.tags = answers.tags.split(',').map(t => t.trim()).filter(Boolean);
+    }
+    if (answers.suggestedPublishAt?.trim()) {
+      data.suggestedPublishAt = new Date(answers.suggestedPublishAt.trim()).toISOString();
+    }
+    if (platformMetadata) {
+      data.platformMetadata = platformMetadata;
+    }
+
+    // Auto-submit flag
+    if (options.submit) {
+      data.submit = true;
+    }
+
+    // Create draft
+    const spinner = villageSpinner('Creating draft...').start();
+    const result = await createMediaDraft(data);
+    spinner.succeed('Draft created!');
+
+    const draft = result.draft;
+    console.log(brand.green(`\n  \u2713 Draft ID: ${chalk.bold(draft.draftId)}`));
+    console.log(brand.teal(`    Platform: ${PLATFORM_LABELS[draft.platform]}`));
+    console.log(brand.teal(`    Status:   ${statusBadge(draft.status)}`));
+
+    // ── File uploads ───────────────────────────────────
+    // Collect files from --file flags or interactive prompts
+    const filesToUpload = [];
+
+    if (options.file) {
+      // --file can be passed multiple times (commander collects into array)
+      const files = Array.isArray(options.file) ? options.file : [options.file];
+      for (const f of files) {
+        const assetType = options.assetType?.toUpperCase() || inferAssetType(f) || 'IMAGE';
+        filesToUpload.push({ path: f, assetType });
+      }
+    } else {
+      // Interactive multi-file loop
+      let addMore = true;
+      while (addMore) {
+        const { wantsUpload } = await inquirer.prompt([{
+          type: 'confirm',
+          name: 'wantsUpload',
+          message: filesToUpload.length === 0
+            ? 'Attach media files?'
+            : 'Attach another file?',
+          default: false,
+        }]);
+
+        if (!wantsUpload) break;
+
+        const fileAnswer = await inquirer.prompt([
+          {
+            type: 'input',
+            name: 'filePath',
+            message: 'File path:',
+            validate: (v) => {
+              if (!v.trim()) return 'File path is required';
+              try {
+                statSync(resolve(v.trim()));
+                return true;
+              } catch {
+                return 'File not found';
+              }
+            },
+          },
+          {
+            type: 'list',
+            name: 'assetType',
+            message: 'Asset type:',
+            choices: [
+              { name: 'Image', value: 'IMAGE' },
+              { name: 'Video', value: 'VIDEO' },
+              { name: 'Thumbnail', value: 'THUMBNAIL' },
+              { name: 'Document', value: 'DOCUMENT' },
+            ],
+            default: () => {
+              // Try to auto-detect from the last input
+              return undefined;
+            },
+          },
+        ]);
+
+        filesToUpload.push({ path: fileAnswer.filePath.trim(), assetType: fileAnswer.assetType });
+      }
+    }
+
+    // Upload all collected files
+    if (filesToUpload.length > 0) {
+      console.log(brand.teal(`\n  Uploading ${filesToUpload.length} file${filesToUpload.length > 1 ? 's' : ''}...\n`));
+      await uploadFiles(draft.id, filesToUpload);
+    }
+
+    // Submit prompt if not already submitted
+    if (!options.submit && draft.status === 'DRAFT') {
+      const { wantsSubmit } = await inquirer.prompt([{
+        type: 'confirm',
+        name: 'wantsSubmit',
+        message: 'Submit for review now?',
+        default: true,
+      }]);
+
+      if (wantsSubmit) {
+        const submitSpinner = villageSpinner('Submitting for review...').start();
+        try {
+          await updateMediaDraft(draft.id, { submit: true });
+          submitSpinner.succeed('Submitted for review!');
+        } catch (err) {
+          const message = err.response?.data?.error || err.message;
+          submitSpinner.fail(`Failed to submit: ${message}`);
+        }
+      }
+    }
+
+    console.log(brand.teal(`\n  Track status: myvillage media draft status ${draft.draftId}\n`));
+  } catch (err) {
+    const message = err.response?.data?.error || err.response?.data?.message || err.message;
+    console.log(chalk.red(`  \u2717 Failed to create draft: ${message}\n`));
+  }
+}
+
+// ── Multi-file upload orchestrator ─────────────────────
+
+async function uploadFiles(draftId, files) {
+  const limit = pLimit(3); // Max 3 concurrent uploads
+
+  const tasks = files.map((file) =>
+    limit(() => uploadSingleFile(draftId, file.path, file.assetType))
+  );
+
+  await Promise.all(tasks);
+}
+
+// ── Single file upload (auto-selects strategy) ─────────
+
+async function uploadSingleFile(draftId, filePath, assetType) {
+  const resolvedPath = resolve(filePath);
+  const fileName = basename(resolvedPath);
+
+  let fileSize;
+  try {
+    const stat = statSync(resolvedPath);
+    fileSize = stat.size;
+  } catch (err) {
+    console.log(chalk.red(`  \u2717 Could not read file: ${err.message}`));
+    return;
+  }
+
+  // Use presigned upload for large files, direct upload for small ones
+  if (fileSize > PRESIGNED_THRESHOLD) {
+    await uploadViaPresignedUrl(draftId, resolvedPath, fileName, fileSize, assetType);
+  } else {
+    await uploadViaDirect(draftId, resolvedPath, fileName, assetType);
+  }
+}
+
+// ── Presigned URL upload (large files — direct to S3) ──
+
+async function uploadViaPresignedUrl(draftId, resolvedPath, fileName, fileSize, assetType) {
+  const contentType = getContentType(fileName);
+  const spinner = villageSpinner(`${fileName} (${formatBytes(fileSize)}) — requesting upload URL...`).start();
+
+  try {
+    // 1. Get presigned URL from API
+    const urlResult = await getMediaDraftUploadUrl(draftId, {
+      fileName,
+      assetType,
+      contentType,
+      fileSize,
+    });
+
+    // 2. Upload directly to S3 with progress
+    spinner.text = chalk.yellow(`${fileName} — uploading to storage...`);
+
+    const fileBuffer = readFileSync(resolvedPath);
+
+    await axios.put(urlResult.uploadUrl, fileBuffer, {
+      headers: {
+        'Content-Type': contentType,
+      },
+      maxBodyLength: Infinity,
+      maxContentLength: Infinity,
+      onUploadProgress: (progressEvent) => {
+        if (progressEvent.total) {
+          const pct = Math.round((progressEvent.loaded / progressEvent.total) * 100);
+          spinner.text = chalk.yellow(`${fileName} — ${pct}% (${formatBytes(progressEvent.loaded)} / ${formatBytes(progressEvent.total)})`);
+        }
+      },
+    });
+
+    // 3. Confirm upload with API
+    spinner.text = chalk.yellow(`${fileName} — confirming...`);
+
+    const confirmResult = await confirmMediaDraftUpload(draftId, {
+      s3Key: urlResult.s3Key,
+      fileName,
+      assetType,
+      contentType,
+    });
+
+    spinner.succeed(`${fileName} (${formatBytes(fileSize)})`);
+    console.log(brand.teal(`    Type: ${confirmResult.asset.assetType}  Uploaded via presigned URL`));
+  } catch (err) {
+    const message = err.response?.data?.error || err.message;
+    spinner.fail(`${fileName} — upload failed: ${message}`);
+  }
+}
+
+// ── Direct upload (small files — via API server) ───────
+
+async function uploadViaDirect(draftId, resolvedPath, fileName, assetType) {
+  const spinner = villageSpinner(`${fileName} — uploading...`).start();
+
+  try {
+    const fileBuffer = readFileSync(resolvedPath);
+    const formData = new FormData();
+    const blob = new Blob([fileBuffer]);
+    formData.append('file', blob, fileName);
+    formData.append('assetType', assetType || 'IMAGE');
+
+    const result = await uploadMediaDraftAsset(draftId, formData);
+    spinner.succeed(`${fileName} (${formatBytes(result.asset.fileSize)})`);
+    console.log(brand.teal(`    Type: ${result.asset.assetType}`));
+  } catch (err) {
+    const message = err.response?.data?.error || err.message;
+    spinner.fail(`${fileName} — upload failed: ${message}`);
+  }
+}
+
+// ── Bytes formatter ────────────────────────────────────
+
+function formatBytes(bytes) {
+  if (!bytes) return 'unknown';
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  if (bytes < 1024 * 1024 * 1024) return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+  return `${(bytes / (1024 * 1024 * 1024)).toFixed(2)} GB`;
+}
+
+// ── media draft edit ───────────────────────────────────
+
+export async function mediaDraftEditCommand(id) {
+  if (!isAuthenticated()) {
+    console.log(chalk.red('  \u2717 Authentication required. Run \'myvillage login\' first.'));
+    return;
+  }
+
+  if (!id) {
+    console.log(chalk.red('  \u2717 Draft ID is required (e.g., MED-2026-0001)'));
+    return;
+  }
+
+  const spinner = villageSpinner(`Loading draft ${id}...`).start();
+
+  let draft;
+  try {
+    const result = await getMediaDraft(id);
+    draft = result.draft;
+    spinner.stop();
+  } catch (err) {
+    if (err.response?.status === 404) {
+      spinner.fail(`Draft not found: ${id}`);
+    } else {
+      spinner.fail(`Failed to load draft: ${err.response?.data?.error || err.message}`);
+    }
+    return;
+  }
+
+  if (!['DRAFT', 'REJECTED'].includes(draft.status)) {
+    console.log(chalk.red(`\n  \u2717 Cannot edit draft in ${draft.status} status.`));
+    console.log(brand.teal('  Only DRAFT or REJECTED drafts can be edited.\n'));
+    return;
+  }
+
+  const platform = draft.platform;
+  const isVideo = ['YOUTUBE', 'TIKTOK'].includes(platform);
+
+  console.log(`\n  ${brand.gold(chalk.bold(`\u2726 Edit Draft \u2014 ${draft.draftId}`))}`);
+  console.log(brand.teal(`    Platform: ${PLATFORM_LABELS[platform]}  Status: ${statusBadge(draft.status)}`));
+
+  if (draft.rejectionReason) {
+    console.log(chalk.red(`    Rejection reason: ${draft.rejectionReason}`));
+  }
+
+  if (draft.reviews?.length > 0) {
+    const lastReview = draft.reviews[0]; // already sorted desc
+    if (lastReview.notes) {
+      console.log(brand.cream(`    Last review notes: ${lastReview.notes}`));
+    }
+  }
+
+  console.log(brand.cream('\n  Press Enter to keep current value, or type a new one.\n'));
+
+  try {
+    // Content fields
+    const contentPrompts = [];
+
+    if (platform === 'YOUTUBE') {
+      contentPrompts.push({
+        type: 'input',
+        name: 'title',
+        message: `Video title:`,
+        default: draft.title || '',
+      });
+    }
+
+    contentPrompts.push({
+      type: 'input',
+      name: 'caption',
+      message: isVideo ? 'Description / caption:' : 'Caption:',
+      default: draft.caption || '',
+    });
+
+    if (isVideo) {
+      contentPrompts.push({
+        type: 'input',
+        name: 'script',
+        message: 'Script:',
+        default: draft.script || '',
+      });
+    }
+
+    contentPrompts.push({
+      type: 'input',
+      name: 'tags',
+      message: 'Tags / hashtags (comma-separated):',
+      default: draft.tags?.join(', ') || '',
+    });
+
+    contentPrompts.push({
+      type: 'input',
+      name: 'suggestedPublishAt',
+      message: 'Suggested publish date (YYYY-MM-DD or YYYY-MM-DDTHH:mm):',
+      default: draft.suggestedPublishAt
+        ? new Date(draft.suggestedPublishAt).toISOString().slice(0, 16)
+        : '',
+    });
+
+    const answers = await inquirer.prompt(contentPrompts);
+
+    // Platform-specific settings
+    const existingMetadata = draft.platformMetadata || {};
+    const platformMetadata = await promptPlatformMetadata(platform, existingMetadata);
+
+    // Build update payload — only send changed fields
+    const updates = {};
+
+    if (platform === 'YOUTUBE' && answers.title !== (draft.title || '')) {
+      updates.title = answers.title.trim() || undefined;
+    }
+    if (answers.caption !== (draft.caption || '')) {
+      updates.caption = answers.caption.trim() || undefined;
+    }
+    if (isVideo && answers.script !== (draft.script || '')) {
+      updates.script = answers.script.trim() || undefined;
+    }
+
+    const newTags = answers.tags
+      ? answers.tags.split(',').map(t => t.trim()).filter(Boolean)
+      : [];
+    const oldTags = draft.tags || [];
+    if (JSON.stringify(newTags) !== JSON.stringify(oldTags)) {
+      updates.tags = newTags;
+    }
+
+    const oldPublish = draft.suggestedPublishAt
+      ? new Date(draft.suggestedPublishAt).toISOString().slice(0, 16)
+      : '';
+    if (answers.suggestedPublishAt !== oldPublish) {
+      updates.suggestedPublishAt = answers.suggestedPublishAt.trim()
+        ? new Date(answers.suggestedPublishAt.trim()).toISOString()
+        : null;
+    }
+
+    if (platformMetadata) {
+      updates.platformMetadata = platformMetadata;
+    }
+
+    // File uploads
+    const filesToUpload = [];
+    let addMore = true;
+    const existingAssets = draft.assets || [];
+
+    if (existingAssets.length > 0) {
+      console.log(brand.teal(`\n  Current files (${existingAssets.length}):`));
+      for (const asset of existingAssets) {
+        console.log(`    ${chalk.dim(asset.assetType)} ${asset.fileName} (${formatBytes(asset.fileSize)})`);
+      }
+    }
+
+    while (addMore) {
+      const { wantsUpload } = await inquirer.prompt([{
+        type: 'confirm',
+        name: 'wantsUpload',
+        message: filesToUpload.length === 0
+          ? 'Attach additional media files?'
+          : 'Attach another file?',
+        default: false,
+      }]);
+
+      if (!wantsUpload) break;
+
+      const fileAnswer = await inquirer.prompt([
+        {
+          type: 'input',
+          name: 'filePath',
+          message: 'File path:',
+          validate: (v) => {
+            if (!v.trim()) return 'File path is required';
+            try {
+              statSync(resolve(v.trim()));
+              return true;
+            } catch {
+              return 'File not found';
+            }
+          },
+        },
+        {
+          type: 'list',
+          name: 'assetType',
+          message: 'Asset type:',
+          choices: [
+            { name: 'Image', value: 'IMAGE' },
+            { name: 'Video', value: 'VIDEO' },
+            { name: 'Thumbnail', value: 'THUMBNAIL' },
+            { name: 'Document', value: 'DOCUMENT' },
+          ],
+        },
+      ]);
+
+      filesToUpload.push({ path: fileAnswer.filePath.trim(), assetType: fileAnswer.assetType });
+    }
+
+    // Apply updates
+    const hasFieldChanges = Object.keys(updates).length > 0;
+    const hasFileChanges = filesToUpload.length > 0;
+
+    if (!hasFieldChanges && !hasFileChanges) {
+      console.log(brand.teal('\n  No changes made.\n'));
+      return;
+    }
+
+    if (hasFieldChanges) {
+      const updateSpinner = villageSpinner('Updating draft...').start();
+      try {
+        await updateMediaDraft(draft.id, updates);
+        updateSpinner.succeed('Draft updated!');
+      } catch (err) {
+        const message = err.response?.data?.error || err.message;
+        updateSpinner.fail(`Failed to update: ${message}`);
+        return;
+      }
+    }
+
+    if (hasFileChanges) {
+      console.log(brand.teal(`\n  Uploading ${filesToUpload.length} file${filesToUpload.length > 1 ? 's' : ''}...\n`));
+      await uploadFiles(draft.id, filesToUpload);
+    }
+
+    // Offer to resubmit if it was rejected
+    if (draft.status === 'REJECTED' || draft.status === 'DRAFT') {
+      const { wantsSubmit } = await inquirer.prompt([{
+        type: 'confirm',
+        name: 'wantsSubmit',
+        message: draft.status === 'REJECTED' ? 'Resubmit for review?' : 'Submit for review?',
+        default: true,
+      }]);
+
+      if (wantsSubmit) {
+        const submitSpinner = villageSpinner('Submitting for review...').start();
+        try {
+          await updateMediaDraft(draft.id, { submit: true });
+          submitSpinner.succeed(draft.status === 'REJECTED' ? 'Resubmitted for review!' : 'Submitted for review!');
+        } catch (err) {
+          const message = err.response?.data?.error || err.message;
+          submitSpinner.fail(`Failed to submit: ${message}`);
+        }
+      }
+    }
+
+    console.log(brand.teal(`\n  Track status: myvillage media draft status ${draft.draftId}\n`));
+  } catch (err) {
+    const message = err.response?.data?.error || err.response?.data?.message || err.message;
+    console.log(chalk.red(`  \u2717 Failed to edit draft: ${message}\n`));
+  }
+}
+
+// ── media draft list ───────────────────────────────────
+
+export async function mediaDraftListCommand(options = {}) {
+  if (!isAuthenticated()) {
+    console.log(chalk.red('  \u2717 Authentication required. Run \'myvillage login\' first.'));
+    return;
+  }
+
+  const spinner = villageSpinner('Loading drafts...').start();
+
+  try {
+    const params = {
+      limit: parseInt(options.limit) || 20,
+      offset: parseInt(options.offset) || 0,
+      sort: options.sort || 'newest',
+    };
+    if (options.status) params.status = options.status.toUpperCase();
+    if (options.platform) params.platform = options.platform.toUpperCase();
+    if (options.search) params.search = options.search;
+
+    const result = await listMediaDrafts(params);
+    spinner.stop();
+
+    if (options.json) {
+      console.log(JSON.stringify(result, null, 2));
+      return;
+    }
+
+    const drafts = result.drafts || [];
+
+    if (drafts.length === 0) {
+      console.log(brand.teal('\n  No media drafts found.\n'));
+      console.log(brand.cream('  Create one with: myvillage media draft create\n'));
+      return;
+    }
+
+    const statusLabel = options.status
+      ? ` \u2014 ${options.status.replace(/_/g, ' ').replace(/\b\w/g, c => c.toUpperCase())}`
+      : '';
+
+    console.log(`\n  ${chalk.bold(`Media Drafts${statusLabel}`)}\n`);
+
+    for (const draft of drafts) {
+      const platform = PLATFORM_LABELS[draft.platform] || draft.platform;
+      const status = statusBadge(draft.status);
+      const preview = draft.caption
+        ? draft.caption.substring(0, 60) + (draft.caption.length > 60 ? '...' : '')
+        : draft.title || draft.script?.substring(0, 60) || '(no content)';
+      const date = new Date(draft.createdAt).toLocaleDateString();
+      const assetCount = draft.assets?.length || draft._count?.assets || 0;
+      const assetLabel = assetCount > 0 ? chalk.dim(` [${assetCount} file${assetCount > 1 ? 's' : ''}]`) : '';
+
+      console.log(`  ${brand.gold(draft.draftId)}  ${status}  ${chalk.dim(platform)}  ${chalk.dim(date)}${assetLabel}`);
+      console.log(`    ${brand.cream(preview)}`);
+      console.log('');
+    }
+
+    const { pagination } = result;
+    if (pagination) {
+      console.log(brand.teal(`  Showing ${drafts.length} of ${pagination.total} drafts`));
+      if (pagination.hasMore) {
+        console.log(brand.teal(`  More results: --offset=${pagination.offset + pagination.limit}`));
+      }
+      console.log('');
+    }
+  } catch (err) {
+    const message = err.response?.data?.error || err.message;
+    spinner.fail(`Failed to load drafts: ${message}`);
+  }
+}
+
+// ── media draft status ─────────────────────────────────
+
+export async function mediaDraftStatusCommand(id) {
+  if (!isAuthenticated()) {
+    console.log(chalk.red('  \u2717 Authentication required. Run \'myvillage login\' first.'));
+    return;
+  }
+
+  if (!id) {
+    console.log(chalk.red('  \u2717 Draft ID is required (e.g., MED-2026-0001)'));
+    return;
+  }
+
+  const spinner = villageSpinner(`Loading status for ${id}...`).start();
+
+  try {
+    const result = await getMediaDraftStatus(id);
+    spinner.stop();
+
+    const platform = PLATFORM_LABELS[result.platform] || result.platform;
+    const status = statusBadge(result.status);
+
+    console.log(`\n  ${chalk.bold('Media Draft Status')}\n`);
+    console.log(`  ${brand.gold('Draft ID:')}    ${result.draftId}`);
+    console.log(`  ${brand.gold('Status:')}      ${status}`);
+    console.log(`  ${brand.gold('Platform:')}    ${platform}`);
+
+    if (result.title) {
+      console.log(`  ${brand.gold('Title:')}       ${result.title}`);
+    }
+    if (result.caption) {
+      console.log(`  ${brand.gold('Caption:')}     ${result.caption}`);
+    }
+    if (result.suggestedPublishAt) {
+      console.log(`  ${brand.gold('Publish at:')}  ${new Date(result.suggestedPublishAt).toLocaleString()}`);
+    }
+    if (result.publishedAt) {
+      console.log(`  ${brand.gold('Published:')}   ${new Date(result.publishedAt).toLocaleString()}`);
+    }
+    if (result.platformPostUrl) {
+      console.log(`  ${brand.gold('Post URL:')}    ${result.platformPostUrl}`);
+    }
+    if (result.rejectionReason) {
+      console.log(`  ${chalk.red('Rejection:')}   ${result.rejectionReason}`);
+    }
+
+    console.log(`  ${brand.gold('Created:')}     ${new Date(result.createdAt).toLocaleString()}`);
+    console.log(`  ${brand.gold('Updated:')}     ${new Date(result.updatedAt).toLocaleString()}`);
+
+    if (result.reviewCount > 0) {
+      console.log(`  ${brand.gold('Reviews:')}     ${result.reviewCount}`);
+    }
+
+    if (result.lastReview) {
+      const review = result.lastReview;
+      console.log(`\n  ${chalk.bold('Latest Review')}`);
+      console.log(`    Action: ${review.action}`);
+      if (review.notes) console.log(`    Notes:  ${review.notes}`);
+      console.log(`    Date:   ${new Date(review.createdAt).toLocaleString()}`);
+    }
+
+    console.log('');
+  } catch (err) {
+    if (err.response?.status === 404) {
+      spinner.fail(`Draft not found: ${id}`);
+    } else {
+      const message = err.response?.data?.error || err.message;
+      spinner.fail(`Failed to load status: ${message}`);
+    }
+  }
+}

package/src/index.js

@@ -57,6 +57,12 @@ import { checkinCommand } from './commands/checkin.js';
 import { discoverCommand } from './commands/discover.js';
 import { logCommand } from './commands/log.js';
 import { storyCommand } from './commands/story.js';
+import {
+  mediaDraftCreateCommand,
+  mediaDraftEditCommand,
+  mediaDraftListCommand,
+  mediaDraftStatusCommand,
+} from './commands/media.js';
 import {
   soulprintInitCommand,
   soulprintIngestCommand,
@@ -398,6 +404,46 @@ export function run() {
     .option('--contact <name>', 'Contact name')
     .action(bizreqsImportCommand);
 
+  // ── Media: Draft Submission Pipeline ──────────────────────
+
+  const mediaCmd = program
+    .command('media')
+    .description('Media draft submission and approval pipeline');
+
+  const mediaDraftCmd = mediaCmd
+    .command('draft')
+    .description('Create and manage social media drafts');
+
+  mediaDraftCmd
+    .command('create')
+    .description('Create a new media draft (interactive)')
+    .option('--submit', 'Auto-submit for review after creation')
+    .option('--file <path...>', 'Attach media files (repeatable)')
+    .option('--asset-type <type>', 'Asset type for --file: IMAGE, VIDEO, THUMBNAIL, DOCUMENT (auto-detected if omitted)')
+    .action(mediaDraftCreateCommand);
+
+  mediaDraftCmd
+    .command('edit <id>')
+    .description('Edit a draft (DRAFT or REJECTED status only)')
+    .action(mediaDraftEditCommand);
+
+  mediaDraftCmd
+    .command('list')
+    .description('List your media drafts')
+    .option('--status <status>', 'Filter: DRAFT, SUBMITTED, IN_REVIEW, APPROVED, REJECTED, SCHEDULED, PUBLISHED')
+    .option('--platform <platform>', 'Filter: LINKEDIN, YOUTUBE, TIKTOK, INSTAGRAM')
+    .option('--search <query>', 'Search by caption, title, or draft ID')
+    .option('--sort <sort>', 'Sort: newest, oldest, publish_date', 'newest')
+    .option('-n, --limit <number>', 'Number of results', '20')
+    .option('--offset <number>', 'Pagination offset', '0')
+    .option('--json', 'Output raw JSON')
+    .action(mediaDraftListCommand);
+
+  mediaDraftCmd
+    .command('status <id>')
+    .description('Check draft status (e.g., MED-2026-0001)')
+    .action(mediaDraftStatusCommand);
+
   // ── SoulPrint Studio: Model Training Pipeline ───────────
 
   const soulprintCmd = program

package/src/utils/agentic-templates.js

@@ -1398,7 +1398,7 @@ export default function AgentChat() {
       <div className="agent-chat-messages">
         {messages.length === 0 && <p style={{ color: '#999' }}>Ask the agent anything about your village...</p>}
         {messages.map((msg, i) => (
-          <div key={i} className={`message ${msg.role}`}>
+          <div key={i} className={\`message \${msg.role}\`}>
             <strong>{msg.role === 'user' ? 'You' : 'Agent'}:</strong> {msg.text}
           </div>
         ))}

package/src/utils/api.js

@@ -466,3 +466,57 @@ export async function getBizReqsSpec(id) {
   const response = await client.get(`/${encodeURIComponent(id)}/spec`);
   return response.data;
 }
+
+// ── Media Drafts API (/api/media/drafts) ────────────────
+
+export async function createMediaDraft(data) {
+  const client = getPlatformClient();
+  const response = await client.post('/media/drafts', data);
+  return response.data;
+}
+
+export async function listMediaDrafts(params = {}) {
+  const client = getPlatformClient();
+  const response = await client.get('/media/drafts', { params });
+  return response.data;
+}
+
+export async function getMediaDraft(id) {
+  const client = getPlatformClient();
+  const response = await client.get(`/media/drafts/${encodeURIComponent(id)}`);
+  return response.data;
+}
+
+export async function updateMediaDraft(id, data) {
+  const client = getPlatformClient();
+  const response = await client.patch(`/media/drafts/${encodeURIComponent(id)}`, data);
+  return response.data;
+}
+
+export async function getMediaDraftStatus(id) {
+  const client = getPlatformClient();
+  const response = await client.get(`/media/drafts/${encodeURIComponent(id)}/status`);
+  return response.data;
+}
+
+export async function uploadMediaDraftAsset(id, formData) {
+  const client = getPlatformClient();
+  const response = await client.post(`/media/drafts/${encodeURIComponent(id)}/upload`, formData, {
+    headers: { 'Content-Type': 'multipart/form-data' },
+    maxBodyLength: Infinity,
+    maxContentLength: Infinity,
+  });
+  return response.data;
+}
+
+export async function getMediaDraftUploadUrl(id, data) {
+  const client = getPlatformClient();
+  const response = await client.post(`/media/drafts/${encodeURIComponent(id)}/upload-url`, data);
+  return response.data;
+}
+
+export async function confirmMediaDraftUpload(id, data) {
+  const client = getPlatformClient();
+  const response = await client.post(`/media/drafts/${encodeURIComponent(id)}/confirm-upload`, data);
+  return response.data;
+}