cashclaw 1.0.0

package/src/integrations/hyrve-bridge.js

@@ -0,0 +1,213 @@
+import { loadConfig } from '../cli/utils/config.js';
+
+const DEFAULT_API_URL = 'https://api.hyrveai.com/v1';
+
+/**
+ * Get the HYRVE API base URL from config or default.
+ */
+async function getApiUrl() {
+  const config = await loadConfig();
+  return config.hyrve?.api_url || DEFAULT_API_URL;
+}
+
+/**
+ * Build request headers for HYRVE API calls.
+ */
+async function getHeaders(config = null) {
+  if (!config) config = await loadConfig();
+  return {
+    'Content-Type': 'application/json',
+    'User-Agent': 'CashClaw/1.0.0',
+    'X-Agent-Id': config.hyrve?.agent_id || '',
+    'X-Agent-Name': config.agent?.name || '',
+  };
+}
+
+/**
+ * Register the CashClaw agent on the HYRVEai marketplace.
+ * This makes the agent discoverable to potential clients.
+ * @param {object} config - CashClaw configuration
+ * @returns {object} Registration result with agent_id
+ */
+export async function registerAgent(config) {
+  const apiUrl = config.hyrve?.api_url || DEFAULT_API_URL;
+
+  const enabledServices = Object.entries(config.services || {})
+    .filter(([_, svc]) => svc.enabled)
+    .map(([key, svc]) => ({
+      type: key,
+      pricing: svc.pricing,
+      description: svc.description,
+    }));
+
+  const payload = {
+    agent_name: config.agent?.name || 'CashClaw Agent',
+    owner_name: config.agent?.owner || '',
+    email: config.agent?.email || '',
+    currency: config.agent?.currency || 'USD',
+    services: enabledServices,
+    stripe_connected: !!config.stripe?.secret_key,
+    version: '1.0.0',
+  };
+
+  try {
+    const response = await fetch(`${apiUrl}/agents/register`, {
+      method: 'POST',
+      headers: await getHeaders(config),
+      body: JSON.stringify(payload),
+    });
+
+    if (!response.ok) {
+      const errBody = await response.text();
+      throw new Error(`HYRVE API error (${response.status}): ${errBody}`);
+    }
+
+    const data = await response.json();
+    return {
+      success: true,
+      agent_id: data.agent_id || data.id,
+      message: data.message || 'Agent registered successfully',
+    };
+  } catch (err) {
+    // If the API is not reachable, return a graceful failure
+    if (err.cause?.code === 'ECONNREFUSED' || err.cause?.code === 'ENOTFOUND' || err.message.includes('fetch')) {
+      return {
+        success: false,
+        agent_id: null,
+        message: 'HYRVEai marketplace is not yet available. Your agent is configured locally and will auto-register when the marketplace launches.',
+      };
+    }
+    return {
+      success: false,
+      agent_id: null,
+      message: `Registration failed: ${err.message}`,
+    };
+  }
+}
+
+/**
+ * Sync agent status with HYRVE marketplace.
+ * Sends current earnings, mission count, and availability.
+ */
+export async function syncStatus() {
+  const config = await loadConfig();
+  const apiUrl = await getApiUrl();
+
+  if (!config.hyrve?.agent_id) {
+    return {
+      success: false,
+      message: 'Agent not registered with HYRVE. Run "cashclaw init" first.',
+    };
+  }
+
+  try {
+    const response = await fetch(`${apiUrl}/agents/${config.hyrve.agent_id}/sync`, {
+      method: 'POST',
+      headers: await getHeaders(config),
+      body: JSON.stringify({
+        status: 'active',
+        stats: config.stats || {},
+        updated_at: new Date().toISOString(),
+      }),
+    });
+
+    if (!response.ok) {
+      throw new Error(`Sync failed (${response.status})`);
+    }
+
+    return { success: true, message: 'Status synced with HYRVE marketplace' };
+  } catch (err) {
+    return {
+      success: false,
+      message: `Sync unavailable: ${err.message}. Local data is up to date.`,
+    };
+  }
+}
+
+/**
+ * List available jobs from the HYRVE marketplace that match
+ * this agent's enabled services.
+ */
+export async function listAvailableJobs() {
+  const config = await loadConfig();
+  const apiUrl = await getApiUrl();
+
+  const enabledTypes = Object.entries(config.services || {})
+    .filter(([_, svc]) => svc.enabled)
+    .map(([key]) => key);
+
+  try {
+    const params = new URLSearchParams({
+      service_types: enabledTypes.join(','),
+      currency: config.agent?.currency || 'USD',
+      limit: '20',
+    });
+
+    const response = await fetch(`${apiUrl}/jobs?${params}`, {
+      headers: await getHeaders(config),
+    });
+
+    if (!response.ok) {
+      throw new Error(`Failed to fetch jobs (${response.status})`);
+    }
+
+    const data = await response.json();
+    return {
+      success: true,
+      jobs: data.jobs || [],
+      total: data.total || 0,
+    };
+  } catch (err) {
+    return {
+      success: false,
+      jobs: [],
+      total: 0,
+      message: `Marketplace unavailable: ${err.message}. Jobs will appear here when HYRVEai launches.`,
+    };
+  }
+}
+
+/**
+ * Accept a job from the HYRVE marketplace.
+ * This creates a mission locally and notifies the marketplace.
+ * @param {string} jobId - The HYRVE job ID to accept
+ */
+export async function acceptJob(jobId) {
+  const config = await loadConfig();
+  const apiUrl = await getApiUrl();
+
+  if (!config.hyrve?.agent_id) {
+    return {
+      success: false,
+      message: 'Agent not registered. Run "cashclaw init" first.',
+    };
+  }
+
+  try {
+    const response = await fetch(`${apiUrl}/jobs/${jobId}/accept`, {
+      method: 'POST',
+      headers: await getHeaders(config),
+      body: JSON.stringify({
+        agent_id: config.hyrve.agent_id,
+        accepted_at: new Date().toISOString(),
+      }),
+    });
+
+    if (!response.ok) {
+      throw new Error(`Failed to accept job (${response.status})`);
+    }
+
+    const data = await response.json();
+    return {
+      success: true,
+      job: data.job || {},
+      mission_template: data.mission_template || null,
+      message: data.message || 'Job accepted successfully',
+    };
+  } catch (err) {
+    return {
+      success: false,
+      message: `Could not accept job: ${err.message}`,
+    };
+  }
+}

package/src/integrations/openclaw-bridge.js

@@ -0,0 +1,207 @@
+import fs from 'fs-extra';
+import path from 'path';
+import os from 'os';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+// CashClaw skills directory (shipped with the package)
+const CASHCLAW_SKILLS_DIR = path.resolve(__dirname, '../../skills');
+
+// Possible OpenClaw workspace locations
+const OPENCLAW_PATHS = [
+  path.join(os.homedir(), '.openclaw', 'workspace', 'skills'),
+  path.join(os.homedir(), 'clawd', 'skills'),
+  path.join(os.homedir(), '.clawd', 'skills'),
+  path.join(os.homedir(), 'openclaw', 'skills'),
+];
+
+/**
+ * Detect if OpenClaw is installed by checking known paths.
+ * @returns {object} { found: boolean, path: string|null, paths_checked: string[] }
+ */
+export async function detectOpenClaw() {
+  for (const skillsPath of OPENCLAW_PATHS) {
+    try {
+      const exists = await fs.pathExists(skillsPath);
+      if (exists) {
+        return {
+          found: true,
+          path: path.dirname(skillsPath), // workspace root
+          skills_dir: skillsPath,
+          paths_checked: OPENCLAW_PATHS,
+        };
+      }
+    } catch {
+      continue;
+    }
+  }
+
+  return {
+    found: false,
+    path: null,
+    skills_dir: null,
+    paths_checked: OPENCLAW_PATHS,
+  };
+}
+
+/**
+ * Get the OpenClaw skills directory.
+ * Uses auto-detection or config override.
+ * @param {string} configOverride - Optional explicit path from config
+ * @returns {string|null} Path to skills directory
+ */
+export async function getSkillsDir(configOverride = null) {
+  if (configOverride && await fs.pathExists(configOverride)) {
+    return configOverride;
+  }
+
+  const detection = await detectOpenClaw();
+  return detection.skills_dir;
+}
+
+/**
+ * List available CashClaw skills that can be installed.
+ * Reads from the cashclaw/skills/ directory shipped with the package.
+ * @returns {Array} List of skill objects
+ */
+export async function listAvailableSkills() {
+  try {
+    const exists = await fs.pathExists(CASHCLAW_SKILLS_DIR);
+    if (!exists) {
+      return [];
+    }
+
+    const entries = await fs.readdir(CASHCLAW_SKILLS_DIR, { withFileTypes: true });
+    const skills = [];
+
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        const skillPath = path.join(CASHCLAW_SKILLS_DIR, entry.name);
+        const skillMd = path.join(skillPath, 'SKILL.md');
+        const hasSkillMd = await fs.pathExists(skillMd);
+
+        skills.push({
+          name: entry.name,
+          path: skillPath,
+          has_skill_md: hasSkillMd,
+        });
+      }
+    }
+
+    return skills;
+  } catch (err) {
+    console.error(`Error listing skills: ${err.message}`);
+    return [];
+  }
+}
+
+/**
+ * List skills currently installed in the OpenClaw workspace.
+ * @param {string} configOverride - Optional explicit skills dir path
+ * @returns {Array} List of installed skill names
+ */
+export async function listInstalledSkills(configOverride = null) {
+  const skillsDir = await getSkillsDir(configOverride);
+  if (!skillsDir) {
+    return [];
+  }
+
+  try {
+    const entries = await fs.readdir(skillsDir, { withFileTypes: true });
+    return entries
+      .filter((e) => e.isDirectory() && e.name.startsWith('cashclaw-'))
+      .map((e) => e.name);
+  } catch (err) {
+    return [];
+  }
+}
+
+/**
+ * Install CashClaw skills into the OpenClaw workspace.
+ * Copies skill directories from cashclaw/skills/ to the OpenClaw skills folder.
+ * @param {string[]} skillNames - Array of skill folder names (e.g. ['cashclaw-seo-auditor'])
+ * @param {string} configOverride - Optional explicit skills dir path
+ * @returns {object} Installation results
+ */
+export async function installSkills(skillNames, configOverride = null) {
+  const targetDir = await getSkillsDir(configOverride);
+
+  if (!targetDir) {
+    return {
+      success: false,
+      installed: [],
+      failed: skillNames.map((n) => ({ name: n, error: 'OpenClaw workspace not found' })),
+      message:
+        'OpenClaw workspace not found. Please install OpenClaw first or set the skills path in config.',
+    };
+  }
+
+  await fs.ensureDir(targetDir);
+
+  const installed = [];
+  const failed = [];
+
+  for (const skillName of skillNames) {
+    const sourcePath = path.join(CASHCLAW_SKILLS_DIR, skillName);
+    const destPath = path.join(targetDir, skillName);
+
+    try {
+      const sourceExists = await fs.pathExists(sourcePath);
+      if (!sourceExists) {
+        failed.push({ name: skillName, error: 'Skill not found in CashClaw package' });
+        continue;
+      }
+
+      // Copy the entire skill directory
+      await fs.copy(sourcePath, destPath, { overwrite: true });
+      installed.push(skillName);
+    } catch (err) {
+      failed.push({ name: skillName, error: err.message });
+    }
+  }
+
+  return {
+    success: failed.length === 0,
+    installed,
+    failed,
+    target_dir: targetDir,
+    message:
+      installed.length > 0
+        ? `Installed ${installed.length} skill(s) to ${targetDir}`
+        : 'No skills were installed',
+  };
+}
+
+/**
+ * Uninstall CashClaw skills from OpenClaw workspace.
+ * @param {string[]} skillNames - Array of skill names to remove
+ * @param {string} configOverride - Optional explicit skills dir path
+ */
+export async function uninstallSkills(skillNames, configOverride = null) {
+  const targetDir = await getSkillsDir(configOverride);
+  if (!targetDir) {
+    return { success: false, removed: [], message: 'OpenClaw workspace not found' };
+  }
+
+  const removed = [];
+  for (const skillName of skillNames) {
+    const destPath = path.join(targetDir, skillName);
+    try {
+      const exists = await fs.pathExists(destPath);
+      if (exists) {
+        await fs.remove(destPath);
+        removed.push(skillName);
+      }
+    } catch {
+      continue;
+    }
+  }
+
+  return {
+    success: true,
+    removed,
+    message: `Removed ${removed.length} skill(s)`,
+  };
+}

package/src/integrations/stripe-connect.js

@@ -0,0 +1,204 @@
+import Stripe from 'stripe';
+import { loadConfig } from '../cli/utils/config.js';
+
+let stripeClient = null;
+
+/**
+ * Initialize or return the Stripe client.
+ * Reads the secret key from CashClaw config.
+ */
+async function getStripe() {
+  if (stripeClient) return stripeClient;
+
+  const config = await loadConfig();
+  const secretKey = config.stripe?.secret_key;
+
+  if (!secretKey) {
+    throw new Error(
+      'Stripe secret key not configured. Run "cashclaw init" or "cashclaw config set stripe.secret_key <key>"'
+    );
+  }
+
+  stripeClient = new Stripe(secretKey, {
+    apiVersion: '2024-12-18.acacia',
+  });
+
+  return stripeClient;
+}
+
+/**
+ * Create a Stripe Payment Link for a one-time payment.
+ * @param {number} amount - Amount in the smallest currency unit (e.g., cents for USD)
+ * @param {string} currency - Three-letter currency code (e.g., 'usd')
+ * @param {string} description - Description of what the payment is for
+ * @returns {object} { id, url, amount, currency }
+ */
+export async function createPaymentLink(amount, currency = 'usd', description = 'CashClaw Service') {
+  const stripe = await getStripe();
+
+  // Create a price for this one-time payment
+  const price = await stripe.prices.create({
+    unit_amount: Math.round(amount * 100), // Convert dollars to cents
+    currency: currency.toLowerCase(),
+    product_data: {
+      name: description,
+    },
+  });
+
+  // Create the payment link
+  const paymentLink = await stripe.paymentLinks.create({
+    line_items: [
+      {
+        price: price.id,
+        quantity: 1,
+      },
+    ],
+    metadata: {
+      source: 'cashclaw',
+      description,
+    },
+  });
+
+  return {
+    id: paymentLink.id,
+    url: paymentLink.url,
+    amount,
+    currency: currency.toLowerCase(),
+    description,
+  };
+}
+
+/**
+ * Create a Stripe Invoice and send it to a customer.
+ * @param {string} customerEmail - Customer's email address
+ * @param {Array} items - Array of { description, amount, currency }
+ * @returns {object} Invoice details
+ */
+export async function createInvoice(customerEmail, items = []) {
+  const stripe = await getStripe();
+
+  // Find or create customer
+  const customers = await stripe.customers.list({ email: customerEmail, limit: 1 });
+  let customer;
+  if (customers.data.length > 0) {
+    customer = customers.data[0];
+  } else {
+    customer = await stripe.customers.create({
+      email: customerEmail,
+      metadata: { source: 'cashclaw' },
+    });
+  }
+
+  // Create invoice
+  const invoice = await stripe.invoices.create({
+    customer: customer.id,
+    collection_method: 'send_invoice',
+    days_until_due: 7,
+    metadata: { source: 'cashclaw' },
+  });
+
+  // Add line items
+  for (const item of items) {
+    await stripe.invoiceItems.create({
+      customer: customer.id,
+      invoice: invoice.id,
+      amount: Math.round((item.amount || 0) * 100),
+      currency: (item.currency || 'usd').toLowerCase(),
+      description: item.description || 'CashClaw Service',
+    });
+  }
+
+  // Finalize and send
+  const finalizedInvoice = await stripe.invoices.finalizeInvoice(invoice.id);
+  await stripe.invoices.sendInvoice(invoice.id);
+
+  return {
+    id: finalizedInvoice.id,
+    number: finalizedInvoice.number,
+    status: finalizedInvoice.status,
+    amount_due: finalizedInvoice.amount_due / 100,
+    currency: finalizedInvoice.currency,
+    hosted_invoice_url: finalizedInvoice.hosted_invoice_url,
+    customer_email: customerEmail,
+  };
+}
+
+/**
+ * Check the status of a Stripe payment or payment intent.
+ * @param {string} paymentId - Payment Intent ID (pi_...) or Payment Link ID (plink_...)
+ * @returns {object} Payment status details
+ */
+export async function getPaymentStatus(paymentId) {
+  const stripe = await getStripe();
+
+  try {
+    if (paymentId.startsWith('pi_')) {
+      const intent = await stripe.paymentIntents.retrieve(paymentId);
+      return {
+        id: intent.id,
+        status: intent.status,
+        amount: intent.amount / 100,
+        currency: intent.currency,
+        created: new Date(intent.created * 1000).toISOString(),
+      };
+    } else if (paymentId.startsWith('in_')) {
+      const invoice = await stripe.invoices.retrieve(paymentId);
+      return {
+        id: invoice.id,
+        status: invoice.status,
+        amount: invoice.amount_due / 100,
+        currency: invoice.currency,
+        created: new Date(invoice.created * 1000).toISOString(),
+        paid: invoice.paid,
+      };
+    } else {
+      throw new Error(`Unknown payment ID format: ${paymentId}`);
+    }
+  } catch (err) {
+    throw new Error(`Could not retrieve payment ${paymentId}: ${err.message}`);
+  }
+}
+
+/**
+ * List recent payments.
+ * @param {number} limit - Max number of payments to return (default 10)
+ * @returns {Array} List of payment details
+ */
+export async function listPayments(limit = 10) {
+  const stripe = await getStripe();
+
+  const paymentIntents = await stripe.paymentIntents.list({
+    limit,
+    metadata: { source: 'cashclaw' },
+  });
+
+  return paymentIntents.data.map((pi) => ({
+    id: pi.id,
+    status: pi.status,
+    amount: pi.amount / 100,
+    currency: pi.currency,
+    description: pi.description || '',
+    created: new Date(pi.created * 1000).toISOString(),
+  }));
+}
+
+/**
+ * Test the Stripe connection with the configured key.
+ * @returns {boolean} true if the connection is valid
+ */
+export async function testConnection() {
+  try {
+    const stripe = await getStripe();
+    const account = await stripe.accounts.retrieve();
+    return {
+      connected: true,
+      account_id: account.id,
+      email: account.email,
+    };
+  } catch (err) {
+    return {
+      connected: false,
+      error: err.message,
+    };
+  }
+}

package/templates/config.default.json

@@ -0,0 +1,83 @@
+{
+  "agent": {
+    "name": "MyCashClaw",
+    "owner": "",
+    "email": "",
+    "currency": "USD",
+    "created_at": ""
+  },
+  "stripe": {
+    "secret_key": "",
+    "connected": false,
+    "mode": "test"
+  },
+  "server": {
+    "port": 3847,
+    "host": "localhost"
+  },
+  "services": {
+    "seo_audit": {
+      "enabled": false,
+      "pricing": {
+        "basic": 9,
+        "standard": 29,
+        "pro": 59
+      },
+      "description": "Automated SEO audits with actionable recommendations"
+    },
+    "content_writing": {
+      "enabled": false,
+      "pricing": {
+        "post_500": 5,
+        "post_1500": 12,
+        "newsletter": 9
+      },
+      "description": "AI-powered blog posts, articles, and newsletters"
+    },
+    "lead_generation": {
+      "enabled": false,
+      "pricing": {
+        "starter_25": 9,
+        "standard_50": 15,
+        "pro_100": 25
+      },
+      "description": "Targeted lead lists with contact info and scoring"
+    },
+    "whatsapp_management": {
+      "enabled": false,
+      "pricing": {
+        "setup": 19,
+        "monthly": 49
+      },
+      "description": "WhatsApp Business setup and automated responses"
+    },
+    "social_media": {
+      "enabled": false,
+      "pricing": {
+        "weekly_1": 9,
+        "weekly_3": 19,
+        "monthly_full": 49
+      },
+      "description": "Social media content creation and scheduling"
+    }
+  },
+  "hyrve": {
+    "api_url": "https://api.hyrveai.com/v1",
+    "registered": false,
+    "agent_id": ""
+  },
+  "openclaw": {
+    "workspace": "",
+    "skills_dir": "",
+    "auto_detected": false
+  },
+  "heartbeat": {
+    "enabled": false,
+    "interval_ms": 60000
+  },
+  "stats": {
+    "total_missions": 0,
+    "completed_missions": 0,
+    "total_earned": 0
+  }
+}