@profullstack/coinpay 0.17.0 → 0.19.0

package/CHANGELOG.md

@@ -5,6 +5,46 @@ All notable changes to `@profullstack/coinpay` will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.19.0] - 2026-10-17
+
+### Added
+- Contractors: `coinpay contractor list|add|get|link|offboard|contract|send|end|pending|approve|reject|bonus|expense|1099`.
+  Invite a contractor (they get a private portal to add a payout wallet, file a W-9 or W-8,
+  sign contracts and submit hours, milestones and expenses), contract fixed, hourly or
+  milestone work, approve submissions, and see who needs a 1099-NEC.
+- Pay runs: `coinpay payrun list|create|get|pay|record|delete`. A run collects fixed fees
+  that are due plus approved work, one line per contractor. `pay <id> --yes` sends from the
+  business payout wallet (signed-in owner only); `record` logs a payment made from your own wallet.
+- SDK: `listContractors`, `addContractor`, `createContract`, `sendContract`, `reviewWorkItem`,
+  `createPayRun`, `payPayRun`, `recordPayRunPayments`, `get1099Summary` and friends.
+- MCP: `contractor_list`, `contractor_get`, `contractor_work_list`, `contractor_work_review`,
+  `pay_run_list`, `pay_run_get`, `pay_run_draft`, `contractor_1099_summary`. None of them sends money.
+
+## [0.18.0] - 2026-10-17
+
+### Added
+- Projects and time tracking: `coinpay project list|create|get|invoice`,
+  `coinpay time log|start|stop|list`. `project invoice` bills unbilled
+  billable time as a draft itemised invoice; billed time is locked.
+- `coinpay invoice aging`: unpaid sent invoices by days past due, per
+  currency and per client.
+- `coinpay invoice settings`: reminder schedule (`--reminders "-3,0,7"`),
+  late fee (`--late-fee 1.5%` or `25`, `--late-fee-after 3`) and branding
+  (`--brand-color`, `--logo-url`, `--footer`).
+- `coinpay client portal-link <id>`: one link where a client sees and pays
+  all their invoices; `--revoke` turns it off.
+- MCP: `invoice_list`, `invoice_get`, `invoice_create_draft`,
+  `invoice_ar_aging`, `project_list`, `project_get`, `time_log`,
+  `project_invoice_time`.
+- SDK: `getArAging`, `getInvoiceSettings`, `updateInvoiceSettings`,
+  `createClientPortalLink`, `revokeClientPortalLink`, `listProjects`,
+  `getProject`, `createProject`, `logTime`, `startTimer`, `stopTimer`,
+  `listTimeEntries`, `invoiceProjectTime`.
+
+### Fixed
+- A flag value that starts with a minus and a digit (`--reminders -3,0,7`)
+  is read as the value instead of as another flag.
+
 ## [0.17.0] - 2026-10-17
 
 ### Added

package/bin/coinpay.js

@@ -31,6 +31,41 @@ import {
   createInvoiceItem,
   deleteInvoiceItem,
 } from '../src/invoices.js';
+import {
+  getArAging,
+  getInvoiceSettings,
+  updateInvoiceSettings,
+  createClientPortalLink,
+  revokeClientPortalLink,
+  listProjects,
+  getProject,
+  createProject,
+  logTime,
+  startTimer,
+  stopTimer,
+  listTimeEntries,
+  invoiceProjectTime,
+} from '../src/projects.js';
+import {
+  listContractors,
+  getContractor,
+  addContractor,
+  createContractorPortalLink,
+  offboardContractor,
+  createContract,
+  sendContract,
+  endContract,
+  listWorkItems,
+  reviewWorkItem,
+  addContractorPayment,
+  listPayRuns,
+  getPayRun,
+  createPayRun,
+  deletePayRun,
+  payPayRun,
+  recordPayRunPayments,
+  get1099Summary,
+} from '../src/contractors.js';
 import { readFileSync, writeFileSync, existsSync, unlinkSync, chmodSync } from 'fs';
 import { execSync, spawn } from 'child_process';
 import { createInterface } from 'readline';
@@ -173,6 +208,11 @@ function createUnauthenticatedClient() {
 }
 
 const BOOLEAN_FLAGS = new Set([
+  // projects, time, client portal
+  'non-billable',
+  'unbilled',
+  'archived',
+  'revoke',
   'active',
   // finances reports / statements
   'wait',
@@ -237,7 +277,7 @@ function parseArgs(args) {
         const next = args[i + 1];
         if (BOOLEAN_FLAGS.has(name)) {
           result.flags[name] = true;
-        } else if (next && !next.startsWith('-')) {
+        } else if (next && (!next.startsWith('-') || /^-\d/.test(next))) {
           setFlag(name, next);
           i++;
         } else {
@@ -471,6 +511,49 @@ ${colors.cyan}Commands:${colors.reset}
     delete <id>           Permanently delete a draft invoice
       --yes               Skip confirmation for publish/send/delete
 
+  ${colors.bright}invoice aging${colors.reset}     Unpaid invoices by days past due (--business-id)
+  ${colors.bright}invoice settings${colors.reset}  Show reminders, late fee, branding; change with
+                    --reminders "-3,0,7" | off, --late-fee 1.5% | 25 | none,
+                    --late-fee-after 3, --brand-color "#7c3aed", --logo-url, --footer
+
+  ${colors.bright}client${colors.reset}
+    portal-link <client-id>   Create a portal link listing all their invoices
+                              (replaces the old link; --revoke to turn it off)
+
+  ${colors.bright}contractor${colors.reset}
+    list                  Contractors (--business-id, --all includes offboarded)
+    add                   --name, --email [--country US] [--title] [--no-invite]
+    get <id>              Wallet, tax form, contracts and work lines
+    link <id>             New portal link (--email to send it)
+    contract <id>         Draft: --title --kind fixed|hourly --rate 2000 [--frequency monthly]
+    send <contract-id>    Sign as the business and send: --signature "Your Name"
+    end <contract-id>     [--reason] [--end YYYY-MM-DD]
+    pending               Work waiting for approval
+    approve <id>...       Approve work lines; reject <id> --note "why"
+    bonus | expense       --contract <id> --amount 250 --description "..."
+    1099                  Totals and who needs a 1099-NEC (--year 2026)
+    offboard <id>         End contracts and revoke the portal link
+
+  ${colors.bright}payrun${colors.reset}
+    list                  Pay runs
+    create                Draft from fixed fees due + approved work [--date YYYY-MM-DD]
+    get <id>              Per-contractor amounts, lines and warnings
+    pay <id> --yes        Send from the business payout wallet (owner login only)
+    record <id>           You paid yourself: --item <item-id> --tx <hash>
+    delete <id>           Discard a draft
+
+  ${colors.bright}project${colors.reset}
+    list                  Projects (--business-id, --archived)
+    create                --name, [--client-id] [--rate 120] [--budget 40]
+    get <id>              Hours, unbilled, billed and paid
+    invoice <id>          Bill unbilled time as a draft invoice
+
+  ${colors.bright}time${colors.reset}
+    log                   --project <id> --minutes 90 | --hours 1.5 [--description] [--non-billable]
+    start                 --project <id> [--description]   start a timer
+    stop                  stop your running timer
+    list                  --project <id> [--unbilled]
+
   ${colors.bright}item${colors.reset}
     list                  Saved products/services (--business-id)
     create                Save one: --name, --price [--unit hour] [--description]
@@ -1164,6 +1247,335 @@ function printInvoiceDetails(invoice, { shareUrl } = {}) {
 /**
  * Invoice commands
  */
+async function handleClientCommand(subcommand, args, flags) {
+  const client = createClient();
+  if (subcommand !== 'portal-link' || args.length !== 1) {
+    print.error('Usage: coinpay client portal-link <client-id> [--revoke]');
+    process.exit(1);
+  }
+  if (flags.revoke) {
+    await revokeClientPortalLink(client, args[0]);
+    print.success('Portal link revoked');
+    return;
+  }
+  const url = await createClientPortalLink(client, args[0]);
+  if (flags.json) print.json({ url });
+  else {
+    print.success('Portal link (any earlier link no longer works):');
+    console.log(url);
+  }
+}
+
+function hoursOf(minutes) {
+  return minutes == null ? 'running' : Math.floor(minutes / 60) + 'h' + String(minutes % 60).padStart(2, '0') + 'm';
+}
+
+const usdText = (n) => '$' + Number(n).toFixed(2);
+
+function usageExit(usage) {
+  print.error('Usage: ' + usage);
+  process.exit(1);
+}
+
+async function handleContractor(subcommand, args, flags) {
+  const client = createClient();
+  requireFlagValues(flags, ['business-id', 'name', 'email', 'country', 'title', 'kind', 'rate', 'frequency', 'start', 'end', 'note', 'signature', 'reason', 'amount', 'contract', 'description', 'status', 'year']);
+  switch (subcommand) {
+    case 'list': {
+      const rows = await listContractors(client, { businessId: flags['business-id'], includeOffboarded: !!flags.all });
+      if (flags.json) return print.json(rows);
+      if (!rows.length) return print.info('No contractors');
+      for (const c of rows) {
+        const bits = [c.status, c.payout_currency || 'no wallet', c.tax_form ? c.tax_form + ' ' + c.tax_status : 'no tax form'];
+        if (c.pending_approvals) bits.push(c.pending_approvals + ' to approve');
+        print.info(c.id + '  ' + c.name + ' <' + c.email + '>  ' + bits.join(' · '));
+      }
+      return;
+    }
+    case 'add': {
+      if (!flags.name || !flags.email) usageExit('coinpay contractor add --name "Ada" --email ada@example.com [--country US] [--no-invite]');
+      const result = await addContractor(client, {
+        businessId: flags['business-id'],
+        name: flags.name,
+        email: flags.email,
+        country: flags.country?.toUpperCase(),
+        jobTitle: flags.title,
+        sendInvite: !flags['no-invite'],
+      });
+      if (flags.json) return print.json(result);
+      print.success('Contractor added: ' + result.contractor.id + (flags['no-invite'] ? '' : ' (invite emailed)'));
+      return print.info('Portal link: ' + result.portal_url);
+    }
+    case 'get': {
+      if (args.length !== 1) usageExit('coinpay contractor get <id>');
+      const data = await getContractor(client, args[0]);
+      if (flags.json) return print.json(data);
+      const c = data.contractor;
+      print.info(c.name + ' <' + c.email + '>  ' + c.status);
+      print.info('Wallet: ' + (c.payout_wallet ? c.payout_currency + ' ' + c.payout_wallet : 'not set'));
+      print.info('Tax form: ' + (c.tax_form ? c.tax_form + ' ' + c.tax_status + (c.tax_id_last4 ? ' •••' + c.tax_id_last4 : '') : 'missing'));
+      for (const k of data.contracts) {
+        const terms = k.kind === 'fixed' ? usdText(k.rate) + ' ' + k.frequency : k.kind === 'hourly' ? usdText(k.rate) + '/h' : 'milestones';
+        print.info('  contract ' + k.id + '  ' + k.title + '  ' + terms + '  ' + k.status);
+      }
+      for (const w of data.work_items.slice(0, 20)) print.info('  ' + w.work_date + '  ' + w.kind + '  ' + usdText(w.amount) + '  ' + w.status + '  ' + w.id);
+      return;
+    }
+    case 'link': {
+      if (args.length !== 1) usageExit('coinpay contractor link <id> [--email]');
+      const url = await createContractorPortalLink(client, args[0], { sendEmail: !!flags.email });
+      return flags.json ? print.json({ url }) : print.info(url);
+    }
+    case 'offboard': {
+      if (args.length !== 1) usageExit('coinpay contractor offboard <id>');
+      await offboardContractor(client, args[0]);
+      return print.success('Offboarded');
+    }
+    case 'contract': {
+      if (args.length !== 1 || !flags.title || !flags.kind) {
+        usageExit('coinpay contractor contract <id> --title "Retainer" --kind fixed|hourly --rate 2000 [--frequency monthly] [--start YYYY-MM-DD]');
+      }
+      if (flags.kind === 'milestone') usageExit('milestone contracts are created in the dashboard (they need a milestone list)');
+      const rate = parseNonNegativeAmount(String(flags.rate ?? ''));
+      if (!rate) usageExit('--rate must be an amount with at most two decimals');
+      const contract = await createContract(client, args[0], {
+        title: flags.title,
+        kind: flags.kind,
+        rate,
+        frequency: flags.frequency,
+        startDate: flags.start,
+        endDate: flags.end,
+      });
+      if (flags.json) return print.json(contract);
+      print.success('Draft contract: ' + contract.id);
+      return print.info('Send it with: coinpay contractor send ' + contract.id + ' --signature "Your Name"');
+    }
+    case 'send': {
+      if (args.length !== 1 || !flags.signature) usageExit('coinpay contractor send <contract-id> --signature "Your Name"');
+      const contract = await sendContract(client, args[0], { signature: flags.signature });
+      return flags.json ? print.json(contract) : print.success('Signed and sent: ' + contract.title);
+    }
+    case 'end': {
+      if (args.length !== 1) usageExit('coinpay contractor end <contract-id> [--reason "..."] [--end YYYY-MM-DD]');
+      const contract = await endContract(client, args[0], { reason: flags.reason, endDate: flags.end });
+      return flags.json ? print.json(contract) : print.success('Contract ended ' + contract.end_date);
+    }
+    case 'pending': {
+      const rows = await listWorkItems(client, { businessId: flags['business-id'], status: flags.status || 'submitted' });
+      if (flags.json) return print.json(rows);
+      if (!rows.length) return print.info('Nothing waiting');
+      for (const w of rows) {
+        print.info(w.id + '  ' + (w.contractors?.name || '') + '  ' + w.kind + (w.minutes ? ' ' + (w.minutes / 60).toFixed(2) + 'h' : '') + '  ' + usdText(w.amount) + '  ' + w.description);
+      }
+      return;
+    }
+    case 'approve':
+    case 'reject': {
+      if (!args.length) usageExit('coinpay contractor ' + subcommand + ' <work-item-id>...' + (subcommand === 'reject' ? ' --note "why"' : ''));
+      for (const workId of args) {
+        const w = await reviewWorkItem(client, workId, { action: subcommand, note: flags.note });
+        print.success((subcommand === 'approve' ? 'Approved ' : 'Rejected ') + w.id + '  ' + usdText(w.amount));
+      }
+      return;
+    }
+    case 'bonus':
+    case 'expense': {
+      if (!flags.contract || !flags.amount || !flags.description) {
+        usageExit('coinpay contractor ' + subcommand + ' --contract <id> --amount 250 --description "..."');
+      }
+      const amount = parseNonNegativeAmount(String(flags.amount));
+      if (!amount) usageExit('--amount must be an amount with at most two decimals');
+      const w = await addContractorPayment(client, { businessId: flags['business-id'], contractId: flags.contract, kind: subcommand, amount, description: flags.description });
+      return flags.json ? print.json(w) : print.success(subcommand + ' added: ' + usdText(w.amount) + ' (goes into the next pay run)');
+    }
+    case '1099': {
+      const year = flags.year ? Number(flags.year) : new Date().getUTCFullYear() - 1;
+      const data = await get1099Summary(client, { businessId: flags['business-id'], year });
+      if (flags.json) return print.json(data);
+      if (!data.contractors.length) return print.info('No contractor payments in ' + year);
+      for (const r of data.contractors) {
+        print.info(String(r.name).padEnd(30) + usdText(r.total_paid).padStart(14) + '  ' + (r.needs_1099_nec ? '1099-NEC' : r.missing_w9 ? 'MISSING W-9' : '-'));
+      }
+      return print.info('Full CSV with tax ids: the Contractors page, Tax forms & 1099 tab (owner only).');
+    }
+    default:
+      usageExit('coinpay contractor <list|add|get|link|offboard|contract|send|end|pending|approve|reject|bonus|expense|1099>');
+  }
+}
+
+async function handlePayRun(subcommand, args, flags) {
+  const client = createClient();
+  requireFlagValues(flags, ['business-id', 'date', 'item', 'tx']);
+  switch (subcommand) {
+    case 'list': {
+      const rows = await listPayRuns(client, { businessId: flags['business-id'] });
+      if (flags.json) return print.json(rows);
+      if (!rows.length) return print.info('No pay runs');
+      for (const r of rows) print.info(r.id + '  #' + r.number + '  ' + r.pay_date + '  ' + usdText(r.total) + '  ' + r.status + '  ' + r.paid + '/' + r.contractors + ' paid');
+      return;
+    }
+    case 'create': {
+      const run = await createPayRun(client, { businessId: flags['business-id'], payDate: flags.date });
+      if (flags.json) return print.json(run);
+      print.success('Drafted pay run #' + run.number + ' for ' + usdText(run.total) + ': ' + run.id);
+      return print.info('Review it with: coinpay payrun get ' + run.id);
+    }
+    case 'get': {
+      if (args.length !== 1) usageExit('coinpay payrun get <id>');
+      const data = await getPayRun(client, args[0]);
+      if (flags.json) return print.json(data);
+      const r = data.pay_run;
+      print.info('Pay run #' + r.number + '  ' + r.pay_date + '  ' + usdText(r.total) + '  ' + r.status);
+      for (const i of data.items) {
+        print.info('  ' + i.id + '  ' + String(i.contractors?.name || '').padEnd(24) + usdText(i.amount).padStart(12) + '  ' + i.status + (i.tx_hash ? '  ' + i.tx_hash : '') + (i.can_send_from_wallet ? '' : '  (pay manually)'));
+        for (const w of i.warnings || []) print.info('      ! ' + w);
+      }
+      return;
+    }
+    case 'pay': {
+      if (args.length !== 1) usageExit('coinpay payrun pay <id> --yes   (sends from the business payout wallet; needs `coinpay login` as the owner)');
+      if (!flags.yes) {
+        print.error('This sends crypto and cannot be undone. Review with `coinpay payrun get ' + args[0] + '`, then add --yes.');
+        process.exit(1);
+      }
+      const result = await payPayRun(client, args[0]);
+      if (flags.json) return print.json(result);
+      for (const o of result.outcomes) {
+        const line = o.contractor + ': ' + o.status + (o.tx_hash ? ' ' + o.tx_hash : '') + (o.error ? ' · ' + o.error : '');
+        if (o.error) print.error(line);
+        else print.success(line);
+      }
+      return print.info('Pay run is ' + result.pay_run.status);
+    }
+    case 'record': {
+      if (args.length !== 1 || !flags.item || !flags.tx) usageExit('coinpay payrun record <id> --item <item-id> --tx <hash>   (you paid from your own wallet)');
+      const result = await recordPayRunPayments(client, args[0], [{ itemId: flags.item, txHash: flags.tx }]);
+      if (flags.json) return print.json(result);
+      const o = result.outcomes[0];
+      return o.error ? print.error(o.error) : print.success('Recorded. Pay run is ' + result.pay_run.status);
+    }
+    case 'delete': {
+      if (args.length !== 1) usageExit('coinpay payrun delete <id>');
+      await deletePayRun(client, args[0]);
+      return print.success('Draft deleted; its lines go back to the approved pool');
+    }
+    default:
+      usageExit('coinpay payrun <list|create|get|pay|record|delete>');
+  }
+}
+
+async function handleProject(subcommand, args, flags) {
+  const client = createClient();
+  requireFlagValues(flags, ['business-id', 'name', 'client-id', 'rate', 'budget', 'currency']);
+  switch (subcommand) {
+    case 'list': {
+      const rows = await listProjects(client, { businessId: flags['business-id'], includeArchived: !!flags.archived });
+      if (flags.json) return print.json(rows);
+      if (!rows.length) return print.info('No projects');
+      for (const p of rows) {
+        print.info(p.id + '  ' + p.name + (p.hourly_rate != null ? '  ' + p.hourly_rate + '/hr' : '') + (p.status === 'archived' ? '  (archived)' : ''));
+      }
+      return;
+    }
+    case 'create': {
+      if (!flags.name) {
+        print.error('--name is required');
+        process.exit(1);
+      }
+      const rate = flags.rate === undefined ? undefined : parseNonNegativeAmount(String(flags.rate));
+      if (rate === null) {
+        print.error('--rate must be an amount with at most two decimals');
+        process.exit(1);
+      }
+      const project = await createProject(client, {
+        businessId: flags['business-id'],
+        name: flags.name,
+        clientId: flags['client-id'],
+        hourlyRate: rate,
+        currency: flags.currency?.toUpperCase(),
+        budgetHours: flags.budget === undefined ? undefined : Number(flags.budget),
+      });
+      if (flags.json) return print.json(project);
+      return print.success('Project created: ' + project.id);
+    }
+    case 'get': {
+      if (args.length !== 1) {
+        print.error('Usage: coinpay project get <id>');
+        process.exit(1);
+      }
+      const { project, stats } = await getProject(client, args[0]);
+      if (flags.json) return print.json({ project, stats });
+      print.info(project.name + (project.hourly_rate != null ? '  ' + project.hourly_rate + '/hr' : ''));
+      print.info('Hours: ' + stats.hours + (project.budget_hours ? ' of ' + project.budget_hours : '') + ' (' + stats.billable_hours + ' billable)');
+      print.info('Unbilled: ' + stats.unbilled_amount + '   Billed: ' + stats.billed_amount + '   Paid: ' + stats.paid_amount);
+      return;
+    }
+    case 'invoice': {
+      if (args.length !== 1) {
+        print.error('Usage: coinpay project invoice <id>');
+        process.exit(1);
+      }
+      const result = await invoiceProjectTime(client, args[0]);
+      if (flags.json) return print.json(result);
+      print.success('Draft ' + result.invoice.invoice_number + ' for ' + result.invoice.amount + ' from ' + result.entries_billed + ' entries');
+      return print.info('Review and send: coinpay invoice send ' + result.invoice.id);
+    }
+    default:
+      print.error('Usage: coinpay project <list|create|get|invoice>');
+      process.exit(1);
+  }
+}
+
+async function handleTime(subcommand, args, flags) {
+  const client = createClient();
+  requireFlagValues(flags, ['project', 'minutes', 'hours', 'description', 'business-id']);
+  switch (subcommand) {
+    case 'log': {
+      const minutes = flags.minutes !== undefined ? Number(flags.minutes) : Math.round(Number(flags.hours) * 60);
+      if (!flags.project || !Number.isInteger(minutes) || minutes < 1) {
+        print.error('Usage: coinpay time log --project <id> --minutes 90 (or --hours 1.5) [--description "..."]');
+        process.exit(1);
+      }
+      const entry = await logTime(client, {
+        projectId: flags.project,
+        minutes,
+        description: flags.description,
+        billable: flags['non-billable'] ? false : undefined,
+      });
+      if (flags.json) return print.json(entry);
+      return print.success('Logged ' + hoursOf(entry.minutes));
+    }
+    case 'start': {
+      if (!flags.project) {
+        print.error('Usage: coinpay time start --project <id> [--description "..."]');
+        process.exit(1);
+      }
+      const entry = await startTimer(client, { projectId: flags.project, description: flags.description });
+      if (flags.json) return print.json(entry);
+      return print.success('Timer started (' + entry.id + ')');
+    }
+    case 'stop': {
+      const entry = await stopTimer(client, { entryId: args[0], businessId: flags['business-id'] });
+      if (flags.json) return print.json(entry);
+      return print.success('Timer stopped: ' + hoursOf(entry.minutes));
+    }
+    case 'list': {
+      const rows = await listTimeEntries(client, { projectId: flags.project, businessId: flags['business-id'], unbilled: !!flags.unbilled });
+      if (flags.json) return print.json(rows);
+      if (!rows.length) return print.info('No time logged');
+      for (const e of rows) {
+        print.info(
+          e.started_at.slice(0, 10) + '  ' + hoursOf(e.minutes).padStart(8) + '  ' + (e.invoice_id ? 'billed  ' : e.billable ? 'unbilled' : 'internal') + '  ' + (e.description || '')
+        );
+      }
+      return;
+    }
+    default:
+      print.error('Usage: coinpay time <log|start|stop|list>');
+      process.exit(1);
+  }
+}
+
 async function handleCatalog(kind, subcommand, args, flags) {
   const client = createClient();
   const isItem = kind === 'item';
@@ -1686,9 +2098,82 @@ async function handleInvoice(subcommand, args, flags) {
       break;
     }
 
+    case 'aging': {
+      requireFlagValues(flags, ['business-id']);
+      const report = await getArAging(client, { businessId: flags['business-id'] });
+      if (flags.json) {
+        print.json(report);
+        break;
+      }
+      if (!report.totals?.length) {
+        print.info('Nothing outstanding');
+        break;
+      }
+      const cols = ['current', '1_30', '31_60', '61_90', '90_plus', 'total'];
+      print.info('                          current     1-30    31-60    61-90      90+    total');
+      for (const row of [...report.totals.map((t) => ({ ...t, name: 'TOTAL ' + t.currency })), ...report.clients]) {
+        print.info(
+          String(row.name).slice(0, 24).padEnd(24) +
+            cols.map((c) => String(row[c] ? row[c].toFixed(2) : '-').padStart(9)).join('')
+        );
+      }
+      break;
+    }
+
+    case 'settings': {
+      requireFlagValues(flags, ['business-id', 'reminders', 'late-fee', 'late-fee-after', 'brand-color', 'logo-url', 'footer']);
+      const changes = {};
+      if (flags.reminders !== undefined) {
+        if (flags.reminders === 'off') changes.reminders_enabled = false;
+        else {
+          const days = String(flags.reminders).split(',').map((d) => Number(d.trim()));
+          if (days.some((d) => !Number.isInteger(d))) {
+            print.error('--reminders must be days relative to the due date, like "-3,0,7", or off');
+            process.exit(1);
+          }
+          changes.reminders_enabled = true;
+          changes.reminder_days = days;
+        }
+      }
+      if (flags['late-fee'] !== undefined) {
+        const fee = String(flags['late-fee']).trim();
+        const m = /^(\d+(?:\.\d{1,2})?)(%?)$/.exec(fee);
+        if (fee === 'none') changes.late_fee_type = 'none';
+        else if (m) Object.assign(changes, { late_fee_type: m[2] ? 'percent' : 'fixed', late_fee_value: Number(m[1]) });
+        else {
+          print.error('--late-fee must be a percent like 1.5%, an amount like 25, or none');
+          process.exit(1);
+        }
+      }
+      if (flags['late-fee-after'] !== undefined) changes.late_fee_after_days = Number(flags['late-fee-after']);
+      if (flags['brand-color'] !== undefined) changes.brand_color = flags['brand-color'] === 'none' ? null : flags['brand-color'];
+      if (flags['logo-url'] !== undefined) changes.logo_url = flags['logo-url'] === 'none' ? null : flags['logo-url'];
+      if (flags.footer !== undefined) changes.invoice_footer = flags.footer === 'none' ? null : flags.footer;
+
+      const settings = Object.keys(changes).length
+        ? await updateInvoiceSettings(client, { businessId: flags['business-id'], ...changes })
+        : await getInvoiceSettings(client, { businessId: flags['business-id'] });
+      if (flags.json) {
+        print.json(settings);
+        break;
+      }
+      print.info('Reminders: ' + (settings.reminders_enabled ? settings.reminder_days.join(', ') + ' days from due' : 'off'));
+      print.info(
+        'Late fee: ' +
+          (settings.late_fee_type === 'none'
+            ? 'none'
+            : (settings.late_fee_type === 'percent' ? settings.late_fee_value + '%' : settings.late_fee_value) +
+              ', ' + settings.late_fee_after_days + ' days after due')
+      );
+      print.info('Brand colour: ' + (settings.brand_color || 'default'));
+      print.info('Logo: ' + (settings.logo_url || 'none'));
+      if (settings.invoice_footer) print.info('Footer: ' + settings.invoice_footer);
+      break;
+    }
+
     default:
       print.error('Unknown invoice command: ' + subcommand);
-      print.info('Available: create, list, get, update, publish, send, delete');
+      print.info('Available: create, list, get, update, publish, send, delete, aging, settings');
       process.exit(1);
   }
 }
@@ -4764,6 +5249,28 @@ async function handleLightning(subcommand, args, flags) {
         await handleInvoice(subcommand, args, flags);
         break;
 
+      case 'client':
+        await handleClientCommand(subcommand, args, flags);
+        break;
+
+      case 'project':
+        await handleProject(subcommand, args, flags);
+        break;
+
+      case 'contractor':
+      case 'contractors':
+        await handleContractor(subcommand, args, flags);
+        break;
+
+      case 'payrun':
+      case 'payruns':
+        await handlePayRun(subcommand, args, flags);
+        break;
+
+      case 'time':
+        await handleTime(subcommand, args, flags);
+        break;
+
       case 'item':
       case 'tax-rate':
         await handleCatalog(command, subcommand, args, flags);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@profullstack/coinpay",
-  "version": "0.17.0",
+  "version": "0.19.0",
   "description": "CoinPay SDK & CLI \u2014 Accept cryptocurrency and card payments (BTC, ETH, SOL, POL, BCH, USDC) with wallet, swap and a live finances dashboard",
   "type": "module",
   "main": "./src/index.js",