@goodandready/dsh-cron 0.3.25 → 0.3.26

package/lib/task-schema.js

@@ -1,180 +1 @@
-import z from '@deepseek-ai/schemastery';
-import { normalizeTaskType } from './runtimes.js';
-import { validateTaskType, PATCHABLE_TASK_FIELDS } from './task-transfer.js';
-import { CHANNEL_IDS } from './channels.js';
-
-export const TaskSchema = z.object({
-  id: z.string(),
-  title: z.string().required(),
-  schedule: z.string().required(),
-  scheduleText: z.string(),
-  type: z.string().default('llm'),
-  prompt: z.string().default(''),
-  delivery: z.string().default('isolated'),
-  status: z.string().default('active'),
-  provider: z.string(),
-  model: z.string(),
-  fallbackProvider: z.string(),
-  fallbackModel: z.string(),
-  silentRule: z.string().default(''),
-  inspectOnFailure: z.boolean().default(false),
-  agentPreset: z.string().default(''),
-  targetSessionId: z.string().default(''),
-  targetSessionReset: z.string().default('never'),
-  sessionTitle: z.string().default(''),
-  timezone: z.string().default(''),
-  misfirePolicy: z.string().default('skip'),
-  maxRetries: z.number().default(0),
-  retryBackoffMs: z.number().default(30000),
-  permissionPreset: z.string().default('default'),
-  captureGitDiff: z.boolean(),
-  kanbanMode: z.string().default('none'),
-  channels: z.array(z.string()).default([]),
-  template: z.string().default(''),
-  env: z.any(),
-  cwd: z.string().default(''),
-  workspaceId: z.string().default(''),
-  worktree: z.boolean().default(false),
-  keepWorktree: z.boolean().default(false),
-  httpMethod: z.string().default('GET'),
-  httpUrl: z.string().default(''),
-  httpHeaders: z.any(),
-  httpBody: z.string().default(''),
-  sshProfileId: z.string().default(''),
-  sshTarget: z.string().default(''),
-  sshPort: z.number().default(0),
-  sshKeyPath: z.string().default(''),
-  dockerImage: z.string().default(''),
-  pythonPath: z.string().default(''),
-  nodePath: z.string().default(''),
-  skillName: z.string().default(''),
-  workflowName: z.string().default(''),
-  webhookEnabled: z.boolean().default(false),
-  webhookToken: z.string(),
-  webhookSecret: z.string(),
-  webhookDebounceMs: z.number(),
-  webhookTrigger: z.any(),
-  onSuccess: z.string().default(''),
-  onFailure: z.string().default(''),
-  heartbeatIntervalSeconds: z.number().default(0),
-  gracePeriodSeconds: z.number().default(300),
-  preflightType: z.string().default('none'),
-  preflightTarget: z.string().default(''),
-  preflightCommand: z.string(),
-  preflightScript: z.string(),
-  concurrencyGroup: z.string().default('default'),
-  priority: z.number().default(5),
-  selfHealingCommand: z.string().default(''),
-  autoDiagnose: z.boolean().default(false),
-  notifyTelegram: z.boolean(),
-  onlyOnFailure: z.boolean(),
-  timeoutSeconds: z.number().default(1800),
-  overlapPolicy: z.string().default('skip'),
-  oneShot: z.boolean().default(false),
-  targetTimestamp: z.number(),
-  nextRunAt: z.number(),
-  costLimitUsd: z.number(),
-  dailyCostLimitUsd: z.number(),
-  tokenLimit: z.number(),
-  pausedReason: z.string(),
-  validators: z.any(),
-  requireApproval: z.boolean().default(false),
-  fileWatch: z.any(),
-  dependsOn: z.array(z.string()).default([]),
-  joinPolicy: z.string().default('all_success'),
-  adaptive: z.any(),
-  adaptiveState: z.any(),
-  promptVersion: z.number(),
-  promptHistory: z.any(),
-  branchRules: z.any(),
-  elseTask: z.string(),
-  autoHeal: z.boolean(),
-  selfHealing: z.any(),
-  revisions: z.any(),
-  previousPrompt: z.string(),
-  previousScript: z.string(),
-  swarm: z.any(),
-  gitDiff: z.any(),
-  maxMemoryMb: z.number().min(0).default(0),
-  executionTimeoutMs: z.number().min(0).default(900000),
-  maxLogBytesPerRun: z.number().min(0).default(5 * 1024 * 1024),
-  cpus: z.number().min(0).default(0),
-  maxArchiveMonths: z.number().min(1).default(6),
-  schemaVersion: z.number().default(2),
-  createdAt: z.number(),
-  updatedAt: z.number(),
-});
-
-export function validateTaskRecord(data) {
-  if (!data || typeof data !== 'object') {
-    throw new TypeError('Task record must be an object');
-  }
-  if (data.title !== undefined && typeof data.title !== 'string') {
-    throw new Error('Task schema validation failed: title must be a string');
-  }
-  const title = String(data.title || '').trim();
-  if (!title) {
-    throw new Error('Task title cannot be empty');
-  }
-  if (data.schedule !== undefined && typeof data.schedule !== 'string') {
-    throw new Error('Task schema validation failed: schedule must be a string');
-  }
-  const schedule = String(data.schedule || '').trim();
-  if (!schedule) {
-    throw new Error('Task schedule cannot be empty');
-  }
-
-  const cleanType = normalizeTaskType(data.type);
-  const typeError = validateTaskType(cleanType, data);
-  if (typeError) {
-    throw new Error(typeError);
-  }
-
-  let validated;
-  try {
-    validated = TaskSchema({
-      ...data,
-      title,
-      schedule,
-      type: cleanType,
-    });
-  } catch (err) {
-    throw new Error(`Task schema validation failed: ${err.message}`);
-  }
-
-  // Filter channels to known channel ids if present
-  if (Array.isArray(validated.channels)) {
-    validated.channels = validated.channels.filter((c) => CHANNEL_IDS.includes(c));
-  }
-
-  // Strip undefined keys
-  for (const k of Object.keys(validated)) {
-    if (validated[k] === undefined) {
-      delete validated[k];
-    }
-  }
-
-  return validated;
-}
-
-export function safeValidateTaskRecord(data) {
-  try {
-    const task = validateTaskRecord(data);
-    return { ok: true, task };
-  } catch (err) {
-    return { ok: false, error: err.message };
-  }
-}
-
-export function validateTaskPatch(patch) {
-  if (!patch || typeof patch !== 'object') {
-    return { ok: false, error: 'Task patch must be an object' };
-  }
-  const clean = {};
-  for (const [key, value] of Object.entries(patch)) {
-    if (PATCHABLE_TASK_FIELDS.includes(key)) {
-      clean[key] = value;
-    }
-  }
-  return { ok: true, patch: clean };
-}
+export * from './store/task-schema.js';

package/lib/task-transfer.js

@@ -1,310 +1 @@
-/**
- * Task transfer helpers: duplication, export and import (#41, #42).
- *
- * Pure functions over plain task objects with no I/O, so the whole
- * configuration-transfer contract is unit-testable and the HTTP layer stays a
- * thin adapter. Kept out of index.js both for cohesion and to keep that file
- * from growing further (see issue #97).
- */
-
-import { randomUUID } from 'node:crypto';
-import { normalizeTaskType } from './runtimes.js';
-import { CHANNEL_IDS } from './channels.js';
-
-/** Task fields a client may patch; the single source of truth below. */
-export const PATCHABLE_TASK_FIELDS = [
-  'title',
-  'schedule',
-  'scheduleText',
-  'prompt',
-  'type',
-  'delivery',
-  'provider',
-  'model',
-  'fallbackProvider',
-  'fallbackModel',
-  'silentRule',
-  'inspectOnFailure',
-  'timezone',
-  'misfirePolicy',
-  'maxRetries',
-  'retryBackoffMs',
-  'permissionPreset',
-  'agentPreset',
-  'targetSessionId',
-  'targetSessionReset',
-  'sessionTitle',
-  'webhookEnabled',
-  'webhookToken',
-  'webhookSecret',
-  'webhookDebounceMs',
-  'webhookTrigger',
-  'env',
-  'cwd',
-  'workspaceId',
-  'worktree',
-  'keepWorktree',
-  'captureGitDiff',
-  'httpMethod',
-  'httpUrl',
-  'httpHeaders',
-  'httpBody',
-  'sshTarget',
-  'sshPort',
-  'sshKeyPath',
-  'sshProfileId',
-  'dockerImage',
-  'pythonPath',
-  'nodePath',
-  'skillName',
-  'workflowName',
-  'notifyTelegram',
-  'onlyOnFailure',
-  'timeoutSeconds',
-  'overlapPolicy',
-  'kanbanMode',
-  'onSuccess',
-  'onFailure',
-  'heartbeatIntervalSeconds',
-  'gracePeriodSeconds',
-  'preflightType',
-  'preflightTarget',
-  'concurrencyGroup',
-  'priority',
-  'selfHealingCommand',
-  'autoDiagnose',
-  'channels',
-  'template',
-  'status',
-  'oneShot',
-  'costLimitUsd',
-  'dailyCostLimitUsd',
-  'tokenLimit',
-  'pausedReason',
-  'validators',
-  'requireApproval',
-  'fileWatch',
-  'dependsOn',
-  'joinPolicy',
-  'adaptive',
-  'adaptiveState',
-  'promptVersion',
-  'promptHistory',
-  'branchRules',
-  'elseTask',
-  'autoHeal',
-  'selfHealing',
-  'revisions',
-  'previousPrompt',
-  'previousScript',
-  'swarm',
-  'maxMemoryMb',
-  'executionTimeoutMs',
-  'maxLogBytesPerRun',
-  'cpus',
-  'maxArchiveMonths',
-  'gitDiff',
-];
-
-/** Fields a duplicate inherits; anything else is runtime state, not config. */
-export const DUPLICATE_TASK_FIELDS = PATCHABLE_TASK_FIELDS.filter((key) => key !== 'status' && key !== 'pausedReason');
-
-/**
- * Task ids that would shadow the collection routes under /dsh-cron/tasks.
- * A task may not use them, otherwise it could never be fetched, paused or
- * deleted again (#42 review finding).
- */
-export const RESERVED_TASK_IDS = ['export', 'import'];
-
-/**
- * Task-level fields that can carry a secret the user typed in by hand
- * (`env` values, authorization headers). The export includes them, so the UI
- * and docs must say so instead of promising a secret-free file.
- */
-export const EXPORT_SECRET_BEARING_FIELDS = ['env', 'httpHeaders', 'httpBody'];
-
-/**
- * Validate runtime-specific task configuration. Returns an error string or
- * null when the payload is usable for the given type.
- */
-export function validateTaskType(type, payload) {
-  const t = normalizeTaskType(type);
-  if (t === 'http') {
-    const raw = String((payload && (payload.httpUrl || payload.prompt)) || '').trim();
-    if (!raw) return 'HTTP tasks require a URL (httpUrl or prompt)';
-    try {
-      // eslint-disable-next-line no-new
-      new URL(raw);
-    } catch {
-      return `Invalid HTTP URL: ${raw}`;
-    }
-  }
-  if (t === 'ssh') {
-    const hasProfile = Boolean(payload && String(payload.sshProfileId || '').trim());
-    const hasTarget = Boolean(payload && String(payload.sshTarget || '').trim());
-    if (!hasProfile && !hasTarget) return 'SSH tasks require sshProfileId (remote-workspace profile) or sshTarget (user@host)';
-  }
-  if (t === 'docker' && !String((payload && payload.dockerImage) || '').trim()) {
-    return 'Docker tasks require dockerImage';
-  }
-  return null;
-}
-
-/**
- * Build a paused copy of a task (#41).
- *
- * Configuration is copied, execution state is not: the copy starts paused with
- * no history, no token/cost totals, no last-run info and no retry counter, so a
- * duplicate can be reviewed before it ever runs. A duplicated one-shot keeps
- * its original schedule string and stays inert until the user resumes it.
- */
-export function buildDuplicateTask(source, { id } = {}) {
-  const copy = {
-    id: id || randomUUID(),
-    title: `${source.title || 'Task'} (copy)`,
-    status: 'paused',
-    createdAt: Date.now(),
-    updatedAt: Date.now(),
-  };
-  for (const key of DUPLICATE_TASK_FIELDS) {
-    if (key === 'title') continue;
-    if (source[key] !== undefined) copy[key] = Array.isArray(source[key]) ? [...source[key]] : source[key];
-  }
-  return copy;
-}
-
-// ---------------------------------------------------- export / import (#42)
-
-/** Document kind marker so a random JSON file is not mistaken for an export. */
-export const TASK_EXPORT_KIND = 'dsh-cron-tasks';
-export const TASK_EXPORT_VERSION = 1;
-
-/** Fields an exported task carries: identity + configuration, never run state. */
-export const EXPORT_TASK_FIELDS = ['id', 'title', ...DUPLICATE_TASK_FIELDS.filter((k) => k !== 'title')];
-
-/** Import strategies: add (new ids), replace (overwrite by id), skip (leave existing). */
-export const IMPORT_STRATEGIES = ['add', 'replace', 'skip'];
-
-/**
- * Serialise tasks for transfer/backup. Run state (history, token and cost
- * totals, last-run info) is deliberately excluded — the file is a
- * configuration artefact. Channels reference credentials by name, but task-level
- * `env` and headers can contain hand-typed secrets, so the caller must not
- * claim the file is secret-free.
- */
-export function buildTaskExport(tasks, { now = Date.now(), sanitize = false } = {}) {
-  const list = Array.isArray(tasks) ? tasks : [];
-  return {
-    kind: TASK_EXPORT_KIND,
-    version: TASK_EXPORT_VERSION,
-    exportedAt: new Date(now).toISOString(),
-    sanitized: Boolean(sanitize),
-    tasks: list.map((task) => {
-      const out = {};
-      for (const key of EXPORT_TASK_FIELDS) {
-        if (task[key] === undefined || key === 'status') continue;
-        if (sanitize && EXPORT_SECRET_BEARING_FIELDS.includes(key)) continue;
-        out[key] = Array.isArray(task[key]) ? [...task[key]] : task[key];
-      }
-      return out;
-    }),
-  };
-}
-
-/**
- * Validate an import document and return sanitised tasks.
- *
- * An import file is external input, so it is treated as untrusted: only
- * whitelisted configuration fields survive, the file's `status` is ignored
- * (imported tasks always start paused, matching the documented behaviour), and
- * a document that would shadow a collection route id is refused. A malformed
- * file is rejected as a whole so nothing is written.
- */
-export function validateImportDocument(doc) {
-  if (!doc || typeof doc !== 'object') return { ok: false, error: 'Import file is not a JSON object' };
-  if (doc.kind !== TASK_EXPORT_KIND) return { ok: false, error: `Not a ${TASK_EXPORT_KIND} export (missing kind marker)` };
-  if (Number(doc.version) > TASK_EXPORT_VERSION) {
-    return { ok: false, error: `Export version ${doc.version} is newer than this plugin understands (${TASK_EXPORT_VERSION})` };
-  }
-  if (!Array.isArray(doc.tasks)) return { ok: false, error: 'Export has no tasks array' };
-  const tasks = [];
-  for (const [index, raw] of doc.tasks.entries()) {
-    if (!raw || typeof raw !== 'object') return { ok: false, error: `Task #${index + 1} is not an object` };
-    if (!raw.title || !String(raw.title).trim()) return { ok: false, error: `Task #${index + 1} has no title` };
-    if (!raw.schedule || !String(raw.schedule).trim()) return { ok: false, error: `Task #${index + 1} has no schedule` };
-    if (!raw.prompt || !String(raw.prompt).trim()) return { ok: false, error: `Task #${index + 1} has no prompt` };
-    const id = raw.id === undefined ? undefined : String(raw.id);
-    if (id && RESERVED_TASK_IDS.includes(id)) {
-      return { ok: false, error: `Task #${index + 1} uses the reserved id "${id}" which would shadow a task route` };
-    }
-    const type = normalizeTaskType(raw.type);
-    const typeError = validateTaskType(type, raw);
-    if (typeError) return { ok: false, error: `Task #${index + 1} ("${raw.title}"): ${typeError}` };
-    const channels = Array.isArray(raw.channels) ? raw.channels.filter((c) => CHANNEL_IDS.includes(c)) : undefined;
-    // Whitelist: drop anything the file tried to smuggle in (counters, history
-    // pointers, unknown keys) and never inherit the file's status.
-    const clean = { status: 'paused', type };
-    for (const key of DUPLICATE_TASK_FIELDS) {
-      if (raw[key] !== undefined) clean[key] = Array.isArray(raw[key]) ? [...raw[key]] : raw[key];
-    }
-    if (clean.env && typeof clean.env === 'object') {
-      const filteredEnv = {};
-      for (const [k, v] of Object.entries(clean.env)) {
-        if (typeof v === 'string' && (v.includes('••••') || v.trim() === '********')) {
-          continue; // Masked secret placeholder from UI/doc must never become literal secret (#240)
-        }
-        filteredEnv[k] = v;
-      }
-      clean.env = filteredEnv;
-    }
-    if (clean.httpHeaders && typeof clean.httpHeaders === 'object') {
-      const filteredHeaders = {};
-      for (const [k, v] of Object.entries(clean.httpHeaders)) {
-        if (typeof v === 'string' && (v.includes('••••') || v.trim() === '********')) {
-          continue;
-        }
-        filteredHeaders[k] = v;
-      }
-      clean.httpHeaders = filteredHeaders;
-    }
-    if (id) clean.id = id;
-    if (channels) clean.channels = channels;
-    tasks.push(clean);
-  }
-  return { ok: true, tasks };
-}
-
-/** True when a task executes host code or contains shell hooks (#212). */
-export function isCodeExecutingTask(task) {
-  if (!task || typeof task !== 'object') return false;
-  const CODE_TYPES = ['script', 'node', 'python', 'ssh', 'docker'];
-  if (CODE_TYPES.includes(normalizeTaskType(task.type))) return true;
-  if (task.command && String(task.command).trim()) return true;
-  if (task.preflightType === 'command' || task.preflightType === 'shell' || (task.preflightCommand && String(task.preflightCommand).trim())) return true;
-  if (task.selfHealingCommand && String(task.selfHealingCommand).trim()) return true;
-  if (task.preflightScript && String(task.preflightScript).trim()) return true;
-  return false;
-}
-
-/** True when any task in a validated batch executes code on the host (#212). */
-export function hasCodeExecutingTask(tasks) {
-  return (tasks || []).some(isCodeExecutingTask);
-}
-
-/**
- * Decide what an import would do, without touching anything. Existing ids are
- * compared against tasks already in the store.
- */
-export function planImport(tasks, existingIds, strategy = 'skip') {
-  const mode = IMPORT_STRATEGIES.includes(strategy) ? strategy : 'skip';
-  const existing = new Set(existingIds || []);
-  const plan = { strategy: mode, add: [], replace: [], skip: [] };
-  for (const task of tasks || []) {
-    const hasId = Boolean(task.id) && existing.has(task.id);
-    if (!hasId) plan.add.push(task);
-    else if (mode === 'replace') plan.replace.push(task);
-    else if (mode === 'skip') plan.skip.push(task);
-    else plan.add.push({ ...task, id: undefined });
-  }
-  return plan;
-}
+export * from './store/task-transfer.js';

package/lib/tui-settings.js

@@ -0,0 +1,157 @@
+/**
+ * dsh-cron TUI settings section (#387).
+ *
+ * Exposes dsh-cron configuration to the terminal settings screen via
+ * the host tuiSettingsSections seam.
+ */
+
+function numFormat(val, defaultVal = '0') {
+  return Number.isFinite(Number(val)) ? String(Number(val)) : defaultVal;
+}
+
+function numParse(text, min = 0) {
+  const s = String(text ?? '').trim();
+  if (s === '') return { kind: 'clear' };
+  const v = Number(s);
+  return Number.isFinite(v) && v >= min ? { kind: 'set', value: v } : { kind: 'clear' };
+}
+
+function textFormat(val) {
+  return String(val || '');
+}
+
+function textParse(text) {
+  const v = String(text || '').trim();
+  return v === '' ? { kind: 'clear' } : { kind: 'set', value: v };
+}
+
+/**
+ * Build declarative settings section for DSH TUI.
+ */
+export function buildTuiSection({ live, store }) {
+  const current = typeof live === 'function' ? live() : (store?.getSettings?.() || {});
+
+  const fields = [
+    // 1. Delivery & Alerts
+    {
+      path: ['botToken'],
+      group: 'delivery',
+      kind: 'text',
+      label: 'Telegram Bot Token',
+      secret: { ref: current.botTokenRef || 'TELEGRAM_BOT_TOKEN' },
+      hint: 'Stored securely in credential store, never in plain config files.',
+    },
+    {
+      path: ['botTokenRef'],
+      group: 'delivery',
+      kind: 'text',
+      label: 'Bot Token Credential Ref',
+      placeholder: 'TELEGRAM_BOT_TOKEN',
+      hint: 'Name of the credential holding the Telegram bot token.',
+      format: textFormat,
+      parse: textParse,
+    },
+    {
+      path: ['chatId'],
+      group: 'delivery',
+      kind: 'text',
+      label: 'Telegram Chat ID',
+      placeholder: '-1001234567890',
+      hint: 'Chat ID for task execution reports and alerts.',
+      format: textFormat,
+      parse: textParse,
+    },
+    {
+      path: ['discordWebhookUrl'],
+      group: 'delivery',
+      kind: 'text',
+      label: 'Discord Webhook URL',
+      placeholder: 'https://discord.com/api/webhooks/...',
+      format: textFormat,
+      parse: textParse,
+    },
+    {
+      path: ['slackWebhookUrl'],
+      group: 'delivery',
+      kind: 'text',
+      label: 'Slack Webhook URL',
+      placeholder: 'https://hooks.slack.com/services/...',
+      format: textFormat,
+      parse: textParse,
+    },
+
+    // 2. Scheduler & Concurrency
+    {
+      path: ['defaultTimezone'],
+      group: 'scheduler',
+      kind: 'text',
+      label: 'Default Timezone',
+      placeholder: 'UTC',
+      hint: 'Default IANA timezone for schedules (e.g. Europe/Moscow, America/New_York, UTC).',
+      format: textFormat,
+      parse: textParse,
+    },
+    {
+      path: ['maxConcurrent'],
+      group: 'scheduler',
+      kind: 'number',
+      label: 'Max Concurrent Tasks',
+      hint: 'Maximum parallel task runs across all schedules (default 2, 0 = unlimited).',
+      format: (val) => numFormat(val, '2'),
+      parse: (text) => numParse(text, 0),
+    },
+
+    // 3. Budgets & Guardrails
+    {
+      path: ['globalDailyCostLimitUsd'],
+      group: 'budgets',
+      kind: 'number',
+      label: 'Daily Cost Limit (USD)',
+      hint: 'Global 24h expenditure limit in USD across all tasks (0 = unlimited).',
+      format: (val) => numFormat(val, '0'),
+      parse: (text) => numParse(text, 0),
+    },
+  ];
+
+  return {
+    ns: 'dsh-cron',
+    title: 'Cron Automations',
+    descriptions: {
+      en: 'Scheduled tasks, background automation, and notification guardrails.',
+      zh: '定时任务、后台自动化与成本防护。',
+    },
+    groups: [
+      { id: 'delivery', title: 'Delivery & Alerts', descriptions: { zh: '推送与告警' } },
+      { id: 'scheduler', title: 'Scheduler & Concurrency', descriptions: { zh: '调度与并发' } },
+      { id: 'budgets', title: 'Budgets & Guardrails', descriptions: { zh: '预算与防护' } },
+    ],
+    fields,
+  };
+}
+
+/**
+ * Register TUI settings section if tuiSettingsSections service is provided.
+ */
+export function applyTuiSettings(ctx, deps) {
+  if (typeof ctx?.inject !== 'function') return;
+  ctx.inject(['tuiSettingsSections'], (tuiCtx) => {
+    let service;
+    try {
+      service = tuiCtx?.tuiSettingsSections || tuiCtx?.get?.('tuiSettingsSections');
+    } catch {
+      service = undefined;
+    }
+    if (!service || typeof service.register !== 'function') return;
+    try {
+      const section = buildTuiSection(deps || {});
+      const dispose = service.register(section);
+      if (typeof ctx.effect === 'function') {
+        ctx.effect(() => () => {
+          try { dispose?.(); } catch { /* explicit best-effort cleanup */ }
+        }, 'dsh-cron: tui settings');
+      }
+    } catch (error) {
+      ctx?.logger?.warn?.('[dsh-cron] Could not register TUI settings: ' + (error?.message || error));
+    }
+  });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@goodandready/dsh-cron",
-  "version": "0.3.25",
+  "version": "0.3.26",
   "description": "Background automation runner for DSH: isolated agent runs, script/HTTP/SSH/Docker runtimes, cost guard, notifications, heartbeats.",
   "type": "module",
   "main": "lib/index.js",
@@ -12,6 +12,7 @@
   },
   "files": [
     "lib/*.js",
+    "lib/**/*.js",
     "lib/client.css",
     "cordis.patch.yml",
     "README.md",