stack/packages/skills/calendar/scripts/calendar.js

#!/usr/bin/env node

/**
 * Mosaic Calendar CLI
 * Interacts with Mosaic Stack's Events API for calendar management
 */

import https from 'https';
import http from 'http';
import { URL } from 'url';

// Configuration
const API_URL = process.env.MOSAIC_API_URL || 'http://localhost:3001';
const WORKSPACE_ID = process.env.MOSAIC_WORKSPACE_ID;
const API_TOKEN = process.env.MOSAIC_API_TOKEN;

/**
 * Make HTTP request to Mosaic API
 */
function apiRequest(method, path, body = null) {
  return new Promise((resolve, reject) => {
    const url = new URL(path, API_URL);
    const isHttps = url.protocol === 'https:';
    const client = isHttps ? https : http;

    const options = {
      method,
      hostname: url.hostname,
      port: url.port || (isHttps ? 443 : 80),
      path: url.pathname + url.search,
      headers: {
        'Content-Type': 'application/json',
        'Authorization': `Bearer ${API_TOKEN}`,
        'X-Workspace-ID': WORKSPACE_ID
      }
    };

    const req = client.request(options, (res) => {
      let data = '';
      res.on('data', (chunk) => data += chunk);
      res.on('end', () => {
        try {
          const parsed = data ? JSON.parse(data) : {};
          if (res.statusCode >= 200 && res.statusCode < 300) {
            resolve(parsed);
          } else {
            // Provide helpful error messages based on status code
            let errorMsg = `HTTP ${res.statusCode}: ${parsed.message || data}`;
            
            if (res.statusCode === 401) {
              errorMsg += '\n  → Check MOSAIC_API_TOKEN is valid';
            } else if (res.statusCode === 403) {
              errorMsg += '\n  → Verify workspace permissions and MOSAIC_WORKSPACE_ID';
            } else if (res.statusCode === 404) {
              errorMsg += '\n  → Resource not found. Check the event ID';
            } else if (res.statusCode === 400) {
              errorMsg += '\n  → Invalid request. Check date formats and required fields';
            }
            
            reject(new Error(errorMsg));
          }
        } catch (err) {
          reject(new Error(`Failed to parse response: ${data}`));
        }
      });
    });

    req.on('error', reject);

    if (body) {
      req.write(JSON.stringify(body));
    }

    req.end();
  });
}

/**
 * Parse command-line arguments
 */
function parseArgs(args) {
  const parsed = { _: [] };
  for (let i = 0; i < args.length; i++) {
    const arg = args[i];
    if (arg.startsWith('--')) {
      const key = arg.slice(2);
      const value = args[i + 1];
      if (value && !value.startsWith('--')) {
        parsed[key] = value;
        i++;
      } else {
        parsed[key] = true;
      }
    } else {
      parsed._.push(arg);
    }
  }
  return parsed;
}

/**
 * Create a new event
 */
async function createEvent(args) {
  if (!args.title || !args.start) {
    throw new Error('Required: --title and --start (ISO 8601 date)');
  }

  const body = {
    title: args.title,
    startTime: args.start,
  };

  if (args.end) body.endTime = args.end;
  if (args.description) body.description = args.description;
  if (args.location) body.location = args.location;
  if (args['all-day'] !== undefined) body.allDay = args['all-day'] === 'true';
  if (args['project-id']) body.projectId = args['project-id'];
  if (args.metadata) body.metadata = JSON.parse(args.metadata);

  const result = await apiRequest('POST', '/events', body);
  return result;
}

/**
 * List events with optional filters
 */
async function listEvents(args) {
  const params = new URLSearchParams();

  if (args.from) params.append('startFrom', args.from);
  if (args.to) params.append('startTo', args.to);
  if (args['project-id']) params.append('projectId', args['project-id']);
  if (args['all-day'] !== undefined) params.append('allDay', args['all-day']);
  if (args.page) params.append('page', args.page);
  if (args.limit) params.append('limit', args.limit);

  const query = params.toString();
  const path = `/events${query ? '?' + query : ''}`;

  const result = await apiRequest('GET', path);
  return result;
}

/**
 * Get a specific event by ID
 */
async function getEvent(eventId) {
  if (!eventId) {
    throw new Error('Event ID required');
  }

  const result = await apiRequest('GET', `/events/${eventId}`);
  return result;
}

/**
 * Update an event
 */
async function updateEvent(eventId, args) {
  if (!eventId) {
    throw new Error('Event ID required');
  }

  const body = {};

  if (args.title) body.title = args.title;
  if (args.start) body.startTime = args.start;
  if (args.end) body.endTime = args.end;
  if (args.description) body.description = args.description;
  if (args.location) body.location = args.location;
  if (args['all-day'] !== undefined) body.allDay = args['all-day'] === 'true';
  if (args['project-id']) body.projectId = args['project-id'];
  if (args.metadata) body.metadata = JSON.parse(args.metadata);

  const result = await apiRequest('PATCH', `/events/${eventId}`, body);
  return result;
}

/**
 * Delete an event
 */
async function deleteEvent(eventId) {
  if (!eventId) {
    throw new Error('Event ID required');
  }

  const result = await apiRequest('DELETE', `/events/${eventId}`);
  return result;
}

/**
 * Main CLI handler
 */
async function main() {
  const args = parseArgs(process.argv.slice(2));
  const command = args._[0];

  // Validate environment
  if (!WORKSPACE_ID) {
    console.error('Error: MOSAIC_WORKSPACE_ID environment variable required');
    process.exit(1);
  }

  if (!API_TOKEN) {
    console.error('Error: MOSAIC_API_TOKEN environment variable required');
    process.exit(1);
  }

  try {
    let result;

    switch (command) {
      case 'create':
        result = await createEvent(args);
        console.log(JSON.stringify(result, null, 2));
        break;

      case 'list':
        result = await listEvents(args);
        console.log(JSON.stringify(result, null, 2));
        break;

      case 'get':
        result = await getEvent(args._[1]);
        console.log(JSON.stringify(result, null, 2));
        break;

      case 'update':
        result = await updateEvent(args._[1], args);
        console.log(JSON.stringify(result, null, 2));
        break;

      case 'delete':
        result = await deleteEvent(args._[1]);
        console.log(JSON.stringify(result, null, 2));
        break;

      case 'help':
      default:
        console.log(`
Mosaic Calendar CLI

Usage:
  node calendar.js <command> [options]

Commands:
  create    Create a new event
  list      List events with optional filters
  get       Get a specific event by ID
  update    Update an event
  delete    Delete an event

Create Options:
  --title        Event title (required)
  --start        Start time in ISO 8601 format (required)
  --end          End time in ISO 8601 format
  --description  Event description
  --location     Event location
  --all-day      All-day event (true/false)
  --project-id   Link to project UUID
  --metadata     JSON metadata object

List Options:
  --from         Start date filter (ISO 8601)
  --to           End date filter (ISO 8601)
  --project-id   Filter by project UUID
  --all-day      Filter all-day events (true/false)
  --page         Page number (default: 1)
  --limit        Results per page (default: 50, max: 100)

Update Options:
  Same as create options (all optional)

Examples:
  node calendar.js create --title "Meeting" --start "2024-01-30T15:00:00Z"
  node calendar.js list --from "2024-01-30" --to "2024-02-05"
  node calendar.js get abc-123-def
  node calendar.js update abc-123-def --title "Updated Meeting"
  node calendar.js delete abc-123-def

Environment:
  MOSAIC_API_URL        API base URL (default: http://localhost:3001)
  MOSAIC_WORKSPACE_ID   Workspace UUID (required)
  MOSAIC_API_TOKEN      Authentication token (required)
        `);
        break;
    }
  } catch (error) {
    console.error('Error:', error.message);
    process.exit(1);
  }
}

// Run if called directly
main();

export {
  createEvent,
  listEvents,
  getEvent,
  updateEvent,
  deleteEvent,
  apiRequest
};