@epilot/cli 0.1.108 → 0.1.109

package/dist/{chunk-QOD77YLW.js → chunk-UDGF4AVJ.js}

@@ -15,6 +15,179 @@ import {
   YELLOW
 } from "./chunk-7ZQ666ZQ.js";
 
+// src/commands/app/schedule.ts
+var MIN_SCHEDULE_INTERVAL_MINUTES = 15;
+var RATE_PATTERN = /^rate\((\d+)\s+(minute|minutes|hour|hours|day|days)\)$/;
+function validateScheduleExpression(expression, minIntervalMinutes = MIN_SCHEDULE_INTERVAL_MINUTES) {
+  const expr = expression.trim();
+  const rate = expr.match(RATE_PATTERN);
+  if (rate) {
+    const value = Number(rate[1]);
+    const unit = rate[2];
+    if (value < 1) {
+      return { valid: false, error: "rate() value must be at least 1" };
+    }
+    const minutes = unit.startsWith("minute") ? value : unit.startsWith("hour") ? value * 60 : value * 24 * 60;
+    if (minutes < minIntervalMinutes) {
+      return {
+        valid: false,
+        error: `Schedule fires every ${minutes} minute(s) \u2014 the minimum interval is ${minIntervalMinutes} minutes`,
+        minIntervalMinutes: minutes
+      };
+    }
+    return { valid: true, minIntervalMinutes: minutes };
+  }
+  if (expr.startsWith("rate(")) {
+    return { valid: false, error: 'Invalid rate expression \u2014 expected e.g. "rate(30 minutes)"' };
+  }
+  let cron;
+  try {
+    cron = parseCron(expr);
+  } catch (err) {
+    return { valid: false, error: err.message };
+  }
+  if (cron.domRestricted && cron.dowRestricted) {
+    return {
+      valid: false,
+      error: "Restricting both day-of-month and day-of-week is not supported \u2014 set one of them to *"
+    };
+  }
+  const gap = minFireGapMinutes(cron, minIntervalMinutes);
+  if (gap === null) {
+    return { valid: false, error: "Schedule never fires" };
+  }
+  if (gap < minIntervalMinutes) {
+    return {
+      valid: false,
+      error: `Schedule fires ${gap} minute(s) apart \u2014 the minimum interval is ${minIntervalMinutes} minutes`,
+      minIntervalMinutes: gap
+    };
+  }
+  return { valid: true, minIntervalMinutes: gap };
+}
+var FIELD_RANGES = [
+  ["minute", 0, 59],
+  ["hour", 0, 23],
+  ["day of month", 1, 31],
+  ["month", 1, 12],
+  ["day of week", 0, 7]
+];
+var MONTH_NAMES = {
+  jan: 1,
+  feb: 2,
+  mar: 3,
+  apr: 4,
+  may: 5,
+  jun: 6,
+  jul: 7,
+  aug: 8,
+  sep: 9,
+  oct: 10,
+  nov: 11,
+  dec: 12
+};
+var DOW_NAMES = { sun: 0, mon: 1, tue: 2, wed: 3, thu: 4, fri: 5, sat: 6 };
+function parseCron(expr) {
+  const fields = expr.split(/\s+/);
+  if (fields.length !== 5) {
+    throw new Error(
+      `Invalid cron expression "${expr}" \u2014 expected 5 fields (minute hour day-of-month month day-of-week)`
+    );
+  }
+  const sets = fields.map((field, i) => {
+    const [label, min, max] = FIELD_RANGES[i];
+    const names = i === 3 ? MONTH_NAMES : i === 4 ? DOW_NAMES : void 0;
+    return parseField(field, label, min, max, names);
+  });
+  const dayOfWeek = sets[4];
+  if (dayOfWeek.has(7)) {
+    dayOfWeek.delete(7);
+    dayOfWeek.add(0);
+  }
+  return {
+    minute: sets[0],
+    hour: sets[1],
+    dayOfMonth: sets[2],
+    month: sets[3],
+    dayOfWeek,
+    domRestricted: fields[2] !== "*",
+    dowRestricted: fields[4] !== "*"
+  };
+}
+function parseField(field, label, min, max, names) {
+  const values = /* @__PURE__ */ new Set();
+  for (const part of field.split(",")) {
+    const [rangePart, stepPart, ...rest] = part.split("/");
+    if (rest.length > 0 || stepPart === "") {
+      throw new Error(`Invalid ${label} field "${field}"`);
+    }
+    const step = stepPart === void 0 ? 1 : Number(stepPart);
+    if (!Number.isInteger(step) || step < 1) {
+      throw new Error(`Invalid step in ${label} field "${field}"`);
+    }
+    let lo;
+    let hi;
+    if (rangePart === "*") {
+      lo = min;
+      hi = max;
+    } else if (rangePart.includes("-")) {
+      const [a, b] = rangePart.split("-");
+      lo = parseValue(a, label, names);
+      hi = parseValue(b, label, names);
+      if (lo > hi) throw new Error(`Invalid range in ${label} field "${field}"`);
+    } else {
+      lo = parseValue(rangePart, label, names);
+      hi = stepPart === void 0 ? lo : max;
+    }
+    if (lo < min || hi > max) {
+      throw new Error(`Value out of range in ${label} field "${field}" (allowed ${min}-${max})`);
+    }
+    for (let v = lo; v <= hi; v += step) values.add(v);
+  }
+  if (values.size === 0) throw new Error(`Empty ${label} field "${field}"`);
+  return values;
+}
+function parseValue(raw, label, names) {
+  if (names) {
+    const named = names[raw.toLowerCase()];
+    if (named !== void 0) return named;
+  }
+  const value = Number(raw);
+  if (!Number.isInteger(value)) {
+    throw new Error(`Invalid value "${raw}" in ${label} field`);
+  }
+  return value;
+}
+function minFireGapMinutes(cron, threshold) {
+  const start = Date.UTC(2024, 0, 1);
+  const totalMinutes = (366 + 60) * 24 * 60;
+  let previous = null;
+  let minGap = Number.POSITIVE_INFINITY;
+  for (let m = 0; m < totalMinutes; m++) {
+    const date = new Date(start + m * 6e4);
+    if (!matches(cron, date)) continue;
+    if (previous !== null) {
+      const gap = m - previous;
+      if (gap < minGap) minGap = gap;
+      if (minGap < threshold) return minGap;
+    }
+    previous = m;
+  }
+  if (previous === null) return null;
+  return minGap === Number.POSITIVE_INFINITY ? 366 * 24 * 60 : minGap;
+}
+function matches(cron, date) {
+  if (!cron.minute.has(date.getUTCMinutes())) return false;
+  if (!cron.hour.has(date.getUTCHours())) return false;
+  if (!cron.month.has(date.getUTCMonth() + 1)) return false;
+  const domMatch = cron.dayOfMonth.has(date.getUTCDate());
+  const dowMatch = cron.dayOfWeek.has(date.getUTCDay());
+  if (cron.domRestricted && cron.dowRestricted) return domMatch || dowMatch;
+  if (cron.domRestricted) return domMatch;
+  if (cron.dowRestricted) return dowMatch;
+  return true;
+}
+
 // src/commands/app/manifest.ts
 import { readFileSync, writeFileSync, existsSync, statSync } from "fs";
 import { resolve, extname } from "path";
@@ -78,9 +251,72 @@ function validateManifest(data) {
       }
     }
   }
+  if (obj.functions !== void 0) {
+    if (!Array.isArray(obj.functions)) {
+      errors.push({ path: "/functions", message: "Must be an array" });
+    } else {
+      validateFunctions(obj.functions, errors);
+    }
+  }
   if (errors.length > 0) return { valid: false, errors };
   return { valid: true, errors: [], manifest: data };
 }
+var FUNCTION_NAME_PATTERN = /^[a-z0-9][a-z0-9-]{0,63}$/;
+var MAX_FUNCTIONS = 10;
+var MAX_SCHEDULED_FUNCTIONS = 5;
+function validateFunctions(functions, errors) {
+  if (functions.length > MAX_FUNCTIONS) {
+    errors.push({ path: "/functions", message: `At most ${MAX_FUNCTIONS} functions per app` });
+  }
+  const seen = /* @__PURE__ */ new Set();
+  let scheduled = 0;
+  for (let i = 0; i < functions.length; i++) {
+    const fn = functions[i];
+    const path = `/functions/${i}`;
+    if (fn.type !== "workflow" && fn.type !== "scheduled") {
+      errors.push({ path: `${path}/type`, message: 'Required: "workflow" or "scheduled"' });
+    }
+    if (fn.type === "scheduled" && fn.schedule === void 0) {
+      errors.push({ path: `${path}/schedule`, message: "Scheduled functions require a schedule expression" });
+    }
+    if (fn.type !== "scheduled" && fn.schedule !== void 0) {
+      errors.push({ path: `${path}/schedule`, message: 'Only functions of type "scheduled" may declare a schedule' });
+    }
+    if (fn.type !== "workflow" && fn.wait_for_callback !== void 0) {
+      errors.push({ path: `${path}/wait_for_callback`, message: "Only valid for workflow functions" });
+    }
+    if (typeof fn.name !== "string" || !FUNCTION_NAME_PATTERN.test(fn.name)) {
+      errors.push({ path: `${path}/name`, message: "Required kebab-case string (a-z, 0-9, dashes; max 64 chars)" });
+    } else if (seen.has(fn.name)) {
+      errors.push({ path: `${path}/name`, message: `Duplicate function name "${fn.name}"` });
+    } else {
+      seen.add(fn.name);
+    }
+    if (typeof fn.handler !== "string" || fn.handler.length === 0) {
+      errors.push({ path: `${path}/handler`, message: "Required path to the bundled handler JS" });
+    }
+    if (fn.schedule !== void 0) {
+      scheduled++;
+      if (typeof fn.schedule !== "string") {
+        errors.push({ path: `${path}/schedule`, message: "Must be a cron or rate() expression string" });
+      } else {
+        const result = validateScheduleExpression(fn.schedule);
+        if (!result.valid) {
+          errors.push({ path: `${path}/schedule`, message: result.error ?? "Invalid schedule expression" });
+        }
+      }
+    }
+    if (fn.schedule_overlap !== void 0 && fn.schedule_overlap !== "skip") {
+      errors.push({ path: `${path}/schedule_overlap`, message: 'Only "skip" is supported' });
+    }
+  }
+  if (scheduled > MAX_SCHEDULED_FUNCTIONS) {
+    errors.push({
+      path: "/functions",
+      message: `At most ${MAX_SCHEDULED_FUNCTIONS} scheduled functions per app (schedules run once per installation)`
+    });
+  }
+}
 function readManifest(path) {
   const absPath = resolve(path);
   if (!existsSync(absPath)) {
@@ -101,6 +337,15 @@ function writeManifest(path, manifest) {
 `, "utf-8");
 }
 var DEFAULT_BASE_URL = "https://app.sls.epilot.io";
+function bumpPatchVersion(version) {
+  const parts = version.split(".");
+  const patch = Number.parseInt(parts[parts.length - 1], 10);
+  if (Number.isNaN(patch)) {
+    throw new Error(`Cannot derive next version from "${version}" \u2014 pass an explicit target version`);
+  }
+  parts[parts.length - 1] = String(patch + 1);
+  return parts.join(".");
+}
 async function request(baseUrl, token, method, path, body) {
   const url = `${baseUrl}${path}`;
   const headers = {
@@ -203,13 +448,27 @@ function createAppApiClient(opts) {
       });
       return roleId;
     },
-    async cloneVersion(appId, version) {
-      return request(
+    async cloneVersion(appId, sourceVersion, targetVersion) {
+      const target = targetVersion ?? bumpPatchVersion(sourceVersion);
+      await request(
         baseUrl,
         getToken(),
         "POST",
-        `/v1/app-configurations/${appId}/versions/${version}/clone`
+        `/v1/app-configurations/${appId}/versions/${sourceVersion}/clone-to/${target}`
       );
+      return { version: target };
+    },
+    /** Returns the app's installation in the caller's org, or null if not installed. */
+    async getInstallation(appId) {
+      try {
+        return await request(baseUrl, getToken(), "GET", `/v1/app/${appId}`);
+      } catch (err) {
+        if (err.message.includes("(404)")) return null;
+        throw err;
+      }
+    },
+    async patchInstallation(appId, payload) {
+      return request(baseUrl, getToken(), "PATCH", `/v1/app/${appId}`, payload);
     },
     async upsertComponent(appId, version, component) {
       const componentId = component.id;
@@ -407,6 +666,7 @@ function toManifest(config, version) {
 }
 
 export {
+  validateScheduleExpression,
   log,
   validateManifest,
   readManifest,

package/dist/{deploy-NRQHZ635.js → deploy-2U5FVEE7.js}

@@ -8,7 +8,7 @@ import {
   uploadDirectoryAsZip,
   uploadFileToPresignedUrl,
   writeManifest
-} from "./chunk-QOD77YLW.js";
+} from "./chunk-UDGF4AVJ.js";
 import "./chunk-M3M3C5WH.js";
 import "./chunk-YHQA2AVG.js";
 import "./chunk-7ZQ666ZQ.js";
@@ -105,15 +105,67 @@ var deploy_default = defineCommand({
         log.warn(`Logo not found: ${logoPath}`);
       }
     }
-    if (manifest.permissions?.length || manifest.blueprint?.manifest_id) {
+    let functionsPayload;
+    if (manifest.functions) {
+      functionsPayload = [];
+      for (const fn of manifest.functions) {
+        const handlerPath = resolve(manifestDir, fn.handler);
+        if (!existsSync(handlerPath)) {
+          log.error(`Handler not found for function "${fn.name}": ${handlerPath} \u2014 run "npm run build" first`);
+          process.exit(1);
+        }
+        const { handler, assets: fnAssets, ...rest } = fn;
+        const payload = { ...rest, code: readFileSync(handlerPath, "utf-8") };
+        if (fnAssets?.zip) {
+          const zipPath = resolve(manifestDir, fnAssets.zip);
+          if (!existsSync(zipPath)) {
+            log.warn(`Config UI directory not found for function "${fn.name}": ${zipPath} \u2014 skipping surface`);
+          } else if (dryRun) {
+            log.info(`[dry-run] Would zip and upload config UI for function ${fn.name}`);
+          } else {
+            const { upload_url, artifact_url } = await client.createZipUploadUrl(
+              appId,
+              targetVersion,
+              `fn-${fn.name}`
+            );
+            const zipSize = await uploadDirectoryAsZip(upload_url, zipPath);
+            log.success(`Uploaded config UI for function ${fn.name} (${formatFileSize(zipSize)})`);
+            payload.surfaces = {
+              flow_action_config: {
+                app_url: artifact_url.replace(/\/[^/]+$/, "/index.html"),
+                zip_url: artifact_url
+              }
+            };
+          }
+        }
+        functionsPayload.push(payload);
+        if (dryRun) {
+          log.info(
+            `[dry-run] Would deploy ${fn.type} function ${fn.name}${fn.schedule ? ` (schedule: ${fn.schedule})` : ""}`
+          );
+        }
+      }
+    }
+    if (manifest.permissions?.length || manifest.blueprint?.manifest_id || functionsPayload) {
       if (dryRun) {
         if (manifest.permissions?.length) {
-          log.info("[dry-run] Would upsert app role in developer org");
+          log.info("[dry-run] Would upsert app role in developer org (if grants changed)");
         }
         log.info("[dry-run] Would update version permissions/blueprint");
       } else {
+        let grantsChanged = true;
+        if (!isNew && manifest.permissions?.length) {
+          try {
+            const remoteVersion = await client.getVersion(appId, targetVersion);
+            const remoteGrants = remoteVersion.role?.grants;
+            grantsChanged = normalizeGrants(remoteGrants) !== normalizeGrants(manifest.permissions);
+          } catch {
+          }
+        }
         let roleId;
-        if (manifest.permissions?.length) {
+        if (manifest.permissions?.length && !grantsChanged) {
+          log.dim("Permissions unchanged \u2014 skipping grant re-provisioning");
+        } else if (manifest.permissions?.length) {
           const orgId = resolveOrgId(args.token, args.profile);
           if (orgId) {
             try {
@@ -131,11 +183,17 @@ var deploy_default = defineCommand({
             log.warn("Could not resolve org id \u2014 attaching grants without a developer-org role");
           }
         }
-        await client.patchVersion(appId, targetVersion, {
-          ...manifest.permissions?.length ? { grants: manifest.permissions, ...roleId ? { role_id: roleId } : {} } : {},
-          ...manifest.blueprint?.manifest_id ? { manifest_id: manifest.blueprint.manifest_id } : {}
-        });
-        log.success(`Updated version ${targetVersion} (permissions/blueprint)`);
+        const sendGrants = Boolean(manifest.permissions?.length && grantsChanged);
+        if (sendGrants || manifest.blueprint?.manifest_id || functionsPayload) {
+          await client.patchVersion(appId, targetVersion, {
+            ...sendGrants ? { grants: manifest.permissions, ...roleId ? { role_id: roleId } : {} } : {},
+            ...manifest.blueprint?.manifest_id ? { manifest_id: manifest.blueprint.manifest_id } : {},
+            ...functionsPayload ? { functions: functionsPayload } : {}
+          });
+          log.success(
+            `Updated version ${targetVersion} (permissions/blueprint${functionsPayload ? `, ${functionsPayload.length} function(s)` : ""})`
+          );
+        }
       }
     }
     for (const comp of manifest.components) {
@@ -222,6 +280,24 @@ var deploy_default = defineCommand({
         }
       }
     }
+    if (!isNew) {
+      if (dryRun) {
+        log.info("[dry-run] Would re-sync the installation in this org (if installed)");
+      } else {
+        try {
+          const installation = await client.getInstallation(appId);
+          if (installation) {
+            await client.patchInstallation(appId, { version: targetVersion });
+            log.success(`Re-synced installation in this org to v${targetVersion}`);
+            log.warn(
+              "Re-syncing disables the installation \u2014 open the app in epilot (Settings \u2192 Apps) and save its configuration to re-enable it."
+            );
+          }
+        } catch (err) {
+          log.warn(`Could not re-sync installation: ${err.message}`);
+        }
+      }
+    }
     if (dryRun) {
       log.header("Dry run complete. No changes were made.");
     } else {
@@ -229,6 +305,11 @@ var deploy_default = defineCommand({
     }
   }
 });
+function normalizeGrants(grants = []) {
+  return JSON.stringify(
+    grants.map((g) => ({ action: g.action, resource: g.resource ?? null })).sort((a, b) => `${a.action}|${a.resource}`.localeCompare(`${b.action}|${b.resource}`))
+  );
+}
 export {
   deploy_default as default
 };

package/dist/dev-JEAHUYQU.js

@@ -0,0 +1,105 @@
+#!/usr/bin/env node
+import {
+  createAppApiClient,
+  log,
+  readManifest
+} from "./chunk-UDGF4AVJ.js";
+import "./chunk-M3M3C5WH.js";
+import "./chunk-YHQA2AVG.js";
+import "./chunk-7ZQ666ZQ.js";
+
+// src/commands/app/dev.ts
+import { defineCommand } from "citty";
+import { resolve } from "path";
+var dev_default = defineCommand({
+  meta: { name: "dev", description: "Serve a component from localhost inside epilot (dev mode)" },
+  args: {
+    path: { type: "positional", description: "Path to manifest.json", required: false },
+    component: { type: "string", alias: "c", description: "Component to override (folder name in components/)" },
+    url: { type: "string", alias: "u", description: "Local dev server URL (default: http://localhost:5173)" },
+    off: { type: "boolean", description: "Disable dev mode and remove the override" },
+    token: { type: "string", alias: "t", description: "Bearer token" },
+    server: { type: "string", alias: "s", description: "Override server base URL" },
+    profile: { type: "string", description: "Use a named profile" }
+  },
+  run: async ({ args }) => {
+    const manifestPath = resolve(args.path ?? "manifest.json");
+    const manifest = readManifest(manifestPath);
+    const client = createAppApiClient({ token: args.token, server: args.server, profile: args.profile });
+    if (!manifest.app_id) {
+      log.error("No app_id in manifest \u2014 deploy the app once before using dev mode.");
+      process.exit(1);
+    }
+    const appId = manifest.app_id;
+    const overrideUrl = args.url ?? "http://localhost:5173";
+    const overridable = manifest.components.filter(
+      (c) => c.component_type === "CUSTOM_JOURNEY_BLOCK" || c.surfaces && Object.keys(c.surfaces).length > 0
+    );
+    let localComponent = args.component ? manifest.components.find((c) => c._dir === args.component) : void 0;
+    if (args.component && !localComponent) {
+      log.error(`Component "${args.component}" not found in manifest (expected its folder name in components/).`);
+      process.exit(1);
+    }
+    if (!localComponent) {
+      if (overridable.length === 1) {
+        localComponent = overridable[0];
+      } else if (overridable.length === 0) {
+        log.error(
+          "No overridable component found \u2014 dev mode works for UI components (capabilities, pages, portal blocks, journey blocks)."
+        );
+        process.exit(1);
+      } else {
+        log.error(
+          `Multiple UI components found \u2014 pick one with --component <name>: ${overridable.map((c) => c._dir).filter(Boolean).join(", ")}`
+        );
+        process.exit(1);
+      }
+    }
+    const config = await client.getConfiguration(appId);
+    const version = config.latest_version;
+    const remoteVersion = await client.getVersion(appId, version);
+    const remoteComponents = remoteVersion.components ?? [];
+    const remoteComponent = remoteComponents.find((c) => c.id === localComponent.id);
+    if (!remoteComponent) {
+      log.error(`Component ${localComponent.id} not found in deployed version ${version} \u2014 deploy first.`);
+      process.exit(1);
+    }
+    if (remoteComponent.component_type === "CUSTOM_JOURNEY_BLOCK") {
+      const configuration = remoteComponent.configuration ?? {};
+      if (args.off) {
+        delete configuration.override_dev_mode;
+      } else {
+        configuration.override_dev_mode = { override_url: overrideUrl };
+      }
+      remoteComponent.configuration = configuration;
+    } else {
+      const surfaces = remoteComponent.surfaces ?? {};
+      for (const surface of Object.values(surfaces)) {
+        if (surface && typeof surface === "object") {
+          if (args.off) {
+            delete surface.override_url;
+          } else {
+            surface.override_url = overrideUrl;
+          }
+        }
+      }
+    }
+    await client.upsertComponent(appId, version, remoteComponent);
+    await client.patchMetadata(appId, { dev_mode: !args.off });
+    if (args.off) {
+      log.header("Dev mode disabled.");
+      log.dim("The component is served from the CDN again.");
+    } else {
+      log.header(`Dev mode enabled for ${localComponent._dir ?? localComponent.id}`);
+      log.info(`epilot now loads this component from ${overrideUrl}`);
+      log.info("");
+      log.info(`  1. cd components/${localComponent._dir ?? "<component>"} && npm run dev`);
+      log.info("  2. Reload the page in epilot to see your changes");
+      log.info("");
+      log.dim("Turn off with: epilot app dev --off  (required before cloning a new version)");
+    }
+  }
+});
+export {
+  dev_default as default
+};

package/dist/{export-ZRDJCALM.js → export-VLAY2KZP.js}

@@ -4,7 +4,7 @@ import {
   log,
   toManifest,
   writeManifest
-} from "./chunk-QOD77YLW.js";
+} from "./chunk-UDGF4AVJ.js";
 import "./chunk-M3M3C5WH.js";
 import "./chunk-YHQA2AVG.js";
 import "./chunk-7ZQ666ZQ.js";