cashclaw 1.0.0

package/src/engine/earnings-tracker.js

@@ -0,0 +1,184 @@
+import fs from 'fs-extra';
+import path from 'path';
+import os from 'os';
+import dayjs from 'dayjs';
+import isoWeek from 'dayjs/plugin/isoWeek.js';
+
+dayjs.extend(isoWeek);
+
+const EARNINGS_FILE = path.join(os.homedir(), '.cashclaw', 'earnings.jsonl');
+
+/**
+ * Ensure the earnings file parent directory exists.
+ */
+async function ensureEarningsFile() {
+  await fs.ensureDir(path.dirname(EARNINGS_FILE));
+  const exists = await fs.pathExists(EARNINGS_FILE);
+  if (!exists) {
+    await fs.writeFile(EARNINGS_FILE, '', 'utf-8');
+  }
+}
+
+/**
+ * Record a new earning entry.
+ * @param {object} data - { mission_id, service_type, amount, currency, client_name, client_email, description, payment_id }
+ * @returns {object} The recorded earning entry
+ */
+export async function recordEarning(data) {
+  await ensureEarningsFile();
+
+  const entry = {
+    id: `earn_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
+    mission_id: data.mission_id || null,
+    service_type: data.service_type || 'general',
+    amount: data.amount || 0,
+    currency: data.currency || 'USD',
+    client_name: data.client_name || 'Unknown',
+    client_email: data.client_email || '',
+    description: data.description || '',
+    payment_id: data.payment_id || null,
+    recorded_at: dayjs().toISOString(),
+  };
+
+  const line = JSON.stringify(entry) + '\n';
+  await fs.appendFile(EARNINGS_FILE, line, 'utf-8');
+
+  return entry;
+}
+
+/**
+ * Read all earning entries from the JSONL file.
+ */
+async function readAllEarnings() {
+  await ensureEarningsFile();
+
+  const content = await fs.readFile(EARNINGS_FILE, 'utf-8');
+  const lines = content.trim().split('\n').filter(Boolean);
+
+  const earnings = [];
+  for (const line of lines) {
+    try {
+      earnings.push(JSON.parse(line));
+    } catch (err) {
+      // Skip malformed lines
+      continue;
+    }
+  }
+
+  // Sort by recorded_at descending
+  earnings.sort((a, b) => new Date(b.recorded_at) - new Date(a.recorded_at));
+  return earnings;
+}
+
+/**
+ * Get the total of all earnings in USD.
+ */
+export async function getTotal() {
+  const earnings = await readAllEarnings();
+  return earnings.reduce((sum, e) => sum + (e.amount || 0), 0);
+}
+
+/**
+ * Get earnings for the current month.
+ */
+export async function getMonthly() {
+  const earnings = await readAllEarnings();
+  const startOfMonth = dayjs().startOf('month');
+
+  const monthly = earnings.filter((e) =>
+    dayjs(e.recorded_at).isAfter(startOfMonth) || dayjs(e.recorded_at).isSame(startOfMonth)
+  );
+
+  return {
+    total: monthly.reduce((sum, e) => sum + (e.amount || 0), 0),
+    count: monthly.length,
+    entries: monthly,
+  };
+}
+
+/**
+ * Get earnings for the current week (ISO week, Mon-Sun).
+ */
+export async function getWeekly() {
+  const earnings = await readAllEarnings();
+  const startOfWeek = dayjs().startOf('isoWeek');
+
+  const weekly = earnings.filter((e) =>
+    dayjs(e.recorded_at).isAfter(startOfWeek) || dayjs(e.recorded_at).isSame(startOfWeek)
+  );
+
+  return {
+    total: weekly.reduce((sum, e) => sum + (e.amount || 0), 0),
+    count: weekly.length,
+    entries: weekly,
+  };
+}
+
+/**
+ * Get earnings for today.
+ */
+export async function getToday() {
+  const earnings = await readAllEarnings();
+  const startOfDay = dayjs().startOf('day');
+
+  const today = earnings.filter((e) =>
+    dayjs(e.recorded_at).isAfter(startOfDay) || dayjs(e.recorded_at).isSame(startOfDay)
+  );
+
+  return {
+    total: today.reduce((sum, e) => sum + (e.amount || 0), 0),
+    count: today.length,
+    entries: today,
+  };
+}
+
+/**
+ * Get earning history (most recent first).
+ * @param {number} limit - Max entries to return (default 50)
+ */
+export async function getHistory(limit = 50) {
+  const earnings = await readAllEarnings();
+  return earnings.slice(0, limit);
+}
+
+/**
+ * Get a breakdown of earnings by service type.
+ */
+export async function getByService() {
+  const earnings = await readAllEarnings();
+  const byService = {};
+
+  for (const e of earnings) {
+    const key = e.service_type || 'general';
+    if (!byService[key]) {
+      byService[key] = { total: 0, count: 0 };
+    }
+    byService[key].total += e.amount || 0;
+    byService[key].count += 1;
+  }
+
+  return byService;
+}
+
+/**
+ * Get daily totals for the last N days (for charting).
+ * @param {number} days - Number of days to look back (default 30)
+ */
+export async function getDailyTotals(days = 30) {
+  const earnings = await readAllEarnings();
+  const result = [];
+
+  for (let i = days - 1; i >= 0; i--) {
+    const date = dayjs().subtract(i, 'day').format('YYYY-MM-DD');
+    const dayEarnings = earnings.filter(
+      (e) => dayjs(e.recorded_at).format('YYYY-MM-DD') === date
+    );
+    result.push({
+      date,
+      total: dayEarnings.reduce((sum, e) => sum + (e.amount || 0), 0),
+      count: dayEarnings.length,
+    });
+  }
+
+  return result;
+}

package/src/engine/mission-runner.js

@@ -0,0 +1,224 @@
+import fs from 'fs-extra';
+import path from 'path';
+import os from 'os';
+import { v4 as uuidv4 } from 'uuid';
+import dayjs from 'dayjs';
+
+const MISSIONS_DIR = path.join(os.homedir(), '.cashclaw', 'missions');
+
+/**
+ * Ensure the missions directory exists.
+ */
+async function ensureMissionsDir() {
+  await fs.ensureDir(MISSIONS_DIR);
+}
+
+/**
+ * Create a new mission from a template and client info.
+ * @param {object} template - Mission template (from missions/*.json)
+ * @param {object} client - Client info { name, email, notes }
+ * @returns {object} The created mission object
+ */
+export async function createMission(template, client = {}) {
+  await ensureMissionsDir();
+
+  const id = uuidv4();
+  const now = dayjs().toISOString();
+
+  const mission = {
+    id,
+    template: template.template || 'custom',
+    service_type: template.service_type || 'general',
+    tier: template.tier || 'basic',
+    name: template.name || 'Untitled Mission',
+    description: template.description || '',
+    price_usd: template.default_price_usd || 0,
+    estimated_hours: template.estimated_hours || 1,
+    skills_required: template.skills_required || [],
+    deliverables: template.deliverables || [],
+    steps: (template.steps || []).map((step, i) => ({
+      index: i,
+      description: step,
+      status: 'pending',
+      completed_at: null,
+    })),
+    client: {
+      name: client.name || 'Unknown',
+      email: client.email || '',
+      notes: client.notes || '',
+    },
+    status: 'created', // created -> in_progress -> completed -> paid | cancelled
+    payment: {
+      status: 'unpaid', // unpaid -> pending -> paid
+      stripe_payment_id: null,
+      payment_link: null,
+      paid_at: null,
+    },
+    created_at: now,
+    started_at: null,
+    completed_at: null,
+    updated_at: now,
+  };
+
+  const missionPath = path.join(MISSIONS_DIR, `${id}.json`);
+  await fs.writeJson(missionPath, mission, { spaces: 2 });
+
+  return mission;
+}
+
+/**
+ * Start a mission by ID - sets status to in_progress.
+ */
+export async function startMission(id) {
+  const mission = await getMission(id);
+  if (!mission) {
+    throw new Error(`Mission not found: ${id}`);
+  }
+  if (mission.status !== 'created') {
+    throw new Error(`Mission ${id} cannot be started (status: ${mission.status})`);
+  }
+
+  mission.status = 'in_progress';
+  mission.started_at = dayjs().toISOString();
+  mission.updated_at = dayjs().toISOString();
+
+  const missionPath = path.join(MISSIONS_DIR, `${id}.json`);
+  await fs.writeJson(missionPath, mission, { spaces: 2 });
+
+  return mission;
+}
+
+/**
+ * Complete a mission by ID - sets status to completed.
+ */
+export async function completeMission(id) {
+  const mission = await getMission(id);
+  if (!mission) {
+    throw new Error(`Mission not found: ${id}`);
+  }
+  if (mission.status !== 'in_progress') {
+    throw new Error(`Mission ${id} cannot be completed (status: ${mission.status})`);
+  }
+
+  mission.status = 'completed';
+  mission.completed_at = dayjs().toISOString();
+  mission.updated_at = dayjs().toISOString();
+
+  // Mark all steps as completed
+  for (const step of mission.steps) {
+    if (step.status === 'pending') {
+      step.status = 'completed';
+      step.completed_at = dayjs().toISOString();
+    }
+  }
+
+  const missionPath = path.join(MISSIONS_DIR, `${id}.json`);
+  await fs.writeJson(missionPath, mission, { spaces: 2 });
+
+  return mission;
+}
+
+/**
+ * Cancel a mission by ID.
+ */
+export async function cancelMission(id) {
+  const mission = await getMission(id);
+  if (!mission) {
+    throw new Error(`Mission not found: ${id}`);
+  }
+  if (mission.status === 'paid') {
+    throw new Error(`Mission ${id} is already paid and cannot be cancelled`);
+  }
+
+  mission.status = 'cancelled';
+  mission.updated_at = dayjs().toISOString();
+
+  const missionPath = path.join(MISSIONS_DIR, `${id}.json`);
+  await fs.writeJson(missionPath, mission, { spaces: 2 });
+
+  return mission;
+}
+
+/**
+ * Update mission step status.
+ */
+export async function updateMissionStep(id, stepIndex, status) {
+  const mission = await getMission(id);
+  if (!mission) {
+    throw new Error(`Mission not found: ${id}`);
+  }
+  if (!mission.steps[stepIndex]) {
+    throw new Error(`Step ${stepIndex} not found in mission ${id}`);
+  }
+
+  mission.steps[stepIndex].status = status;
+  if (status === 'completed') {
+    mission.steps[stepIndex].completed_at = dayjs().toISOString();
+  }
+  mission.updated_at = dayjs().toISOString();
+
+  const missionPath = path.join(MISSIONS_DIR, `${id}.json`);
+  await fs.writeJson(missionPath, mission, { spaces: 2 });
+
+  return mission;
+}
+
+/**
+ * List all missions, optionally filtered by status.
+ */
+export async function listMissions(statusFilter = null) {
+  await ensureMissionsDir();
+
+  const files = await fs.readdir(MISSIONS_DIR);
+  const jsonFiles = files.filter((f) => f.endsWith('.json'));
+
+  const missions = [];
+  for (const file of jsonFiles) {
+    try {
+      const mission = await fs.readJson(path.join(MISSIONS_DIR, file));
+      if (!statusFilter || mission.status === statusFilter) {
+        missions.push(mission);
+      }
+    } catch (err) {
+      // Skip corrupted files
+      continue;
+    }
+  }
+
+  // Sort by created_at descending
+  missions.sort((a, b) => new Date(b.created_at) - new Date(a.created_at));
+  return missions;
+}
+
+/**
+ * Get a single mission by ID.
+ */
+export async function getMission(id) {
+  const missionPath = path.join(MISSIONS_DIR, `${id}.json`);
+  try {
+    const exists = await fs.pathExists(missionPath);
+    if (!exists) return null;
+    return await fs.readJson(missionPath);
+  } catch (err) {
+    return null;
+  }
+}
+
+/**
+ * Get mission statistics.
+ */
+export async function getMissionStats() {
+  const all = await listMissions();
+  return {
+    total: all.length,
+    created: all.filter((m) => m.status === 'created').length,
+    in_progress: all.filter((m) => m.status === 'in_progress').length,
+    completed: all.filter((m) => m.status === 'completed').length,
+    cancelled: all.filter((m) => m.status === 'cancelled').length,
+    paid: all.filter((m) => m.status === 'paid').length,
+    total_value: all.reduce((sum, m) => sum + (m.price_usd || 0), 0),
+    completed_value: all
+      .filter((m) => m.status === 'completed' || m.status === 'paid')
+      .reduce((sum, m) => sum + (m.price_usd || 0), 0),
+  };
+}

package/src/engine/scheduler.js

@@ -0,0 +1,139 @@
+import { listMissions } from './mission-runner.js';
+import { loadConfig } from '../cli/utils/config.js';
+
+let heartbeatTimer = null;
+let isRunning = false;
+
+/**
+ * Start the heartbeat scheduler that periodically checks for
+ * pending missions and unpaid invoices.
+ * @param {number} intervalMs - Interval in milliseconds (default: 60000)
+ */
+export function startHeartbeat(intervalMs = 60000) {
+  if (isRunning) {
+    console.log('[scheduler] Heartbeat already running.');
+    return;
+  }
+
+  isRunning = true;
+  console.log(`[scheduler] Heartbeat started (interval: ${intervalMs}ms)`);
+
+  // Run immediately on start
+  tick();
+
+  heartbeatTimer = setInterval(tick, intervalMs);
+}
+
+/**
+ * Stop the heartbeat scheduler.
+ */
+export function stopHeartbeat() {
+  if (heartbeatTimer) {
+    clearInterval(heartbeatTimer);
+    heartbeatTimer = null;
+  }
+  isRunning = false;
+  console.log('[scheduler] Heartbeat stopped.');
+}
+
+/**
+ * Single tick of the heartbeat: check pending work.
+ */
+async function tick() {
+  try {
+    await checkPendingMissions();
+    await checkUnpaidInvoices();
+  } catch (err) {
+    console.error(`[scheduler] Heartbeat tick error: ${err.message}`);
+  }
+}
+
+/**
+ * Check for missions that are created but not started,
+ * or in_progress missions that may need attention.
+ * @returns {object} Summary of pending missions
+ */
+export async function checkPendingMissions() {
+  try {
+    const created = await listMissions('created');
+    const inProgress = await listMissions('in_progress');
+
+    const summary = {
+      pending_start: created.length,
+      in_progress: inProgress.length,
+      missions_needing_attention: [],
+    };
+
+    // Flag missions that have been in_progress for more than 24 hours
+    const now = Date.now();
+    for (const mission of inProgress) {
+      const startedAt = new Date(mission.started_at).getTime();
+      const hoursElapsed = (now - startedAt) / (1000 * 60 * 60);
+      if (hoursElapsed > mission.estimated_hours * 2) {
+        summary.missions_needing_attention.push({
+          id: mission.id,
+          name: mission.name,
+          hours_elapsed: Math.round(hoursElapsed * 10) / 10,
+          estimated_hours: mission.estimated_hours,
+        });
+      }
+    }
+
+    if (summary.pending_start > 0 || summary.missions_needing_attention.length > 0) {
+      console.log(
+        `[scheduler] Pending: ${summary.pending_start} to start, ` +
+        `${summary.in_progress} in progress, ` +
+        `${summary.missions_needing_attention.length} overdue`
+      );
+    }
+
+    return summary;
+  } catch (err) {
+    console.error(`[scheduler] Error checking pending missions: ${err.message}`);
+    return { pending_start: 0, in_progress: 0, missions_needing_attention: [] };
+  }
+}
+
+/**
+ * Check for completed missions that haven't been paid yet.
+ * @returns {object} Summary of unpaid invoices
+ */
+export async function checkUnpaidInvoices() {
+  try {
+    const completed = await listMissions('completed');
+
+    const unpaid = completed.filter(
+      (m) => m.payment && m.payment.status === 'unpaid'
+    );
+
+    const summary = {
+      unpaid_count: unpaid.length,
+      unpaid_total: unpaid.reduce((sum, m) => sum + (m.price_usd || 0), 0),
+      unpaid_missions: unpaid.map((m) => ({
+        id: m.id,
+        name: m.name,
+        amount: m.price_usd,
+        client: m.client?.name || 'Unknown',
+        completed_at: m.completed_at,
+      })),
+    };
+
+    if (summary.unpaid_count > 0) {
+      console.log(
+        `[scheduler] Unpaid invoices: ${summary.unpaid_count} ($${summary.unpaid_total})`
+      );
+    }
+
+    return summary;
+  } catch (err) {
+    console.error(`[scheduler] Error checking unpaid invoices: ${err.message}`);
+    return { unpaid_count: 0, unpaid_total: 0, unpaid_missions: [] };
+  }
+}
+
+/**
+ * Check if heartbeat is currently running.
+ */
+export function isHeartbeatRunning() {
+  return isRunning;
+}