@lumerahq/cli 0.18.0 → 0.18.1

package/README.md

@@ -95,6 +95,63 @@ The CLI checks for credentials in this order:
 2. Project-local credentials (`.lumera/credentials.json`)
 3. Global credentials (`~/.config/lumera/credentials.json`)
 
+## Automation schedules in `config.json`
+
+Automations can define schedules in two supported shapes.
+
+### Canonical format
+
+```json
+{
+  "external_id": "my-app:daily-report",
+  "name": "Daily Report",
+  "inputs": {
+    "schema": {
+      "function": {
+        "name": "main",
+        "parameters": { "type": "object" }
+      }
+    },
+    "presets": {
+      "daily": {
+        "label": "Daily Run",
+        "inputs": { "region": "west" }
+      }
+    }
+  },
+  "schedule": {
+    "cron": "0 7 * * *",
+    "timezone": "America/Los_Angeles",
+    "preset": "daily"
+  }
+}
+```
+
+### Shorthand format
+
+```json
+{
+  "external_id": "my-app:daily-report",
+  "name": "Daily Report",
+  "inputs": {
+    "schema": {
+      "function": {
+        "name": "main",
+        "parameters": { "type": "object" }
+      }
+    }
+  },
+  "schedule": "0 7 * * *",
+  "schedule_tz": "America/Los_Angeles",
+  "schedule_inputs": { "region": "west" }
+}
+```
+
+Notes:
+- `schedule_inputs` creates/updates a schedule preset automatically.
+- If you already define `inputs.presets`, you can point the schedule at one with `schedule_preset` (or `schedule.preset`).
+- If exactly one preset exists, the CLI uses it automatically.
+
 ## Security
 
 ### Credential Storage

package/dist/index.js

@@ -215,25 +215,25 @@ async function main() {
     switch (command) {
       // Resource commands
       case "plan":
-        await import("./resources-HLQTZV37.js").then((m) => m.plan(args.slice(1)));
+        await import("./resources-E4XMWX7N.js").then((m) => m.plan(args.slice(1)));
         break;
       case "apply":
-        await import("./resources-HLQTZV37.js").then((m) => m.apply(args.slice(1)));
+        await import("./resources-E4XMWX7N.js").then((m) => m.apply(args.slice(1)));
         break;
       case "pull":
-        await import("./resources-HLQTZV37.js").then((m) => m.pull(args.slice(1)));
+        await import("./resources-E4XMWX7N.js").then((m) => m.pull(args.slice(1)));
         break;
       case "destroy":
-        await import("./resources-HLQTZV37.js").then((m) => m.destroy(args.slice(1)));
+        await import("./resources-E4XMWX7N.js").then((m) => m.destroy(args.slice(1)));
         break;
       case "list":
-        await import("./resources-HLQTZV37.js").then((m) => m.list(args.slice(1)));
+        await import("./resources-E4XMWX7N.js").then((m) => m.list(args.slice(1)));
         break;
       case "show":
-        await import("./resources-HLQTZV37.js").then((m) => m.show(args.slice(1)));
+        await import("./resources-E4XMWX7N.js").then((m) => m.show(args.slice(1)));
         break;
       case "diff":
-        await import("./resources-HLQTZV37.js").then((m) => m.diff(args.slice(1)));
+        await import("./resources-E4XMWX7N.js").then((m) => m.diff(args.slice(1)));
         break;
       // Development
       case "dev":

package/dist/{resources-HLQTZV37.js → resources-E4XMWX7N.js}

@@ -84,6 +84,169 @@ function computeLineDiff(oldText, newText) {
   }
   return result;
 }
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function sortJsonValue(value) {
+  if (Array.isArray(value)) {
+    return value.map((item) => sortJsonValue(item));
+  }
+  if (!isPlainObject(value)) {
+    return value;
+  }
+  return Object.fromEntries(
+    Object.entries(value).sort(([a], [b]) => a.localeCompare(b)).map(([key, child]) => [key, sortJsonValue(child)])
+  );
+}
+function stableJsonStringify(value) {
+  return JSON.stringify(sortJsonValue(value));
+}
+function normalizeJsonComparable(value) {
+  if (value === void 0 || value === null || value === "") return "";
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    if (!trimmed) return "";
+    try {
+      return stableJsonStringify(JSON.parse(trimmed));
+    } catch {
+      return trimmed;
+    }
+  }
+  return stableJsonStringify(value);
+}
+function resolveLocalPresetKey(localPresets, presetRef) {
+  if (!presetRef) return void 0;
+  if (presetRef in localPresets) return presetRef;
+  for (const [key, preset] of Object.entries(localPresets)) {
+    if ((preset.label || key) === presetRef) {
+      return key;
+    }
+  }
+  return void 0;
+}
+function resolveSchedulePresetName(schedule, localPresets) {
+  return localPresets[schedule.preset]?.label || schedule.preset;
+}
+function buildLocalPresetComparisonMap(localPresets) {
+  const out = /* @__PURE__ */ new Map();
+  for (const [key, preset] of Object.entries(localPresets)) {
+    out.set(preset.label || key, normalizeJsonComparable(preset.inputs));
+  }
+  return out;
+}
+function buildRemotePresetComparisonMap(remotePresets) {
+  const out = /* @__PURE__ */ new Map();
+  for (const preset of remotePresets) {
+    out.set(preset.name, normalizeJsonComparable(preset.inputs));
+  }
+  return out;
+}
+function comparisonMapsDiffer(left, right) {
+  if (left.size !== right.size) return true;
+  for (const [key, value] of left) {
+    if (right.get(key) !== value) return true;
+  }
+  return false;
+}
+function normalizeLocalAutomation(config) {
+  let inputs;
+  if (config.inputs) {
+    inputs = {
+      schema: config.inputs.schema,
+      presets: config.inputs.presets ? { ...config.inputs.presets } : void 0
+    };
+  }
+  if (config.schedule_tz !== void 0 && typeof config.schedule_tz !== "string") {
+    throw new Error("schedule_tz must be a string");
+  }
+  if (config.schedule_preset !== void 0 && typeof config.schedule_preset !== "string") {
+    throw new Error("schedule_preset must be a string");
+  }
+  if (config.schedule_inputs !== void 0 && !isPlainObject(config.schedule_inputs)) {
+    throw new Error("schedule_inputs must be an object");
+  }
+  let scheduleCron = "";
+  let scheduleTimezone = config.schedule_tz?.trim();
+  let schedulePresetRef = config.schedule_preset?.trim();
+  const hasScheduleInputs = config.schedule_inputs !== void 0;
+  if (typeof config.schedule === "string") {
+    scheduleCron = config.schedule.trim();
+  } else if (config.schedule === void 0 || config.schedule === null) {
+    scheduleCron = "";
+  } else if (isPlainObject(config.schedule)) {
+    if (typeof config.schedule.cron !== "string" || config.schedule.cron.trim() === "") {
+      throw new Error("schedule.cron must be a non-empty string");
+    }
+    scheduleCron = config.schedule.cron.trim();
+    if (config.schedule.timezone !== void 0) {
+      if (typeof config.schedule.timezone !== "string") {
+        throw new Error("schedule.timezone must be a string");
+      }
+      scheduleTimezone = config.schedule.timezone.trim();
+    }
+    if (config.schedule.preset !== void 0) {
+      if (typeof config.schedule.preset !== "string") {
+        throw new Error("schedule.preset must be a string");
+      }
+      schedulePresetRef = config.schedule.preset.trim();
+    }
+  } else {
+    throw new Error("schedule must be a string or object");
+  }
+  const noSchedule = scheduleCron === "" || /^none$/i.test(scheduleCron);
+  if (noSchedule) {
+    if (schedulePresetRef || hasScheduleInputs) {
+      throw new Error("schedule_preset and schedule_inputs require schedule");
+    }
+    return {
+      external_id: config.external_id,
+      name: config.name,
+      description: config.description,
+      inputs
+    };
+  }
+  const localPresets = inputs?.presets ? { ...inputs.presets } : {};
+  if (hasScheduleInputs) {
+    const existingKey = resolveLocalPresetKey(localPresets, schedulePresetRef);
+    const fallbackKey = Object.keys(localPresets).length === 1 ? Object.keys(localPresets)[0] : "schedule";
+    const presetKey = existingKey || schedulePresetRef || fallbackKey;
+    const existingPreset = localPresets[presetKey];
+    localPresets[presetKey] = {
+      label: existingPreset?.label || schedulePresetRef || "Scheduled Run",
+      inputs: config.schedule_inputs
+    };
+    schedulePresetRef = presetKey;
+  } else {
+    const resolvedKey = resolveLocalPresetKey(localPresets, schedulePresetRef);
+    if (resolvedKey) {
+      schedulePresetRef = resolvedKey;
+    }
+  }
+  if (!schedulePresetRef) {
+    const presetKeys = Object.keys(localPresets);
+    if (presetKeys.length === 1) {
+      schedulePresetRef = presetKeys[0];
+    }
+  }
+  if (!schedulePresetRef) {
+    throw new Error("schedule requires a preset. Add schedule.preset, schedule_preset, or schedule_inputs");
+  }
+  const normalizedInputs = inputs ? {
+    ...inputs,
+    presets: Object.keys(localPresets).length > 0 ? localPresets : inputs.presets
+  } : Object.keys(localPresets).length > 0 ? { presets: localPresets } : void 0;
+  return {
+    external_id: config.external_id,
+    name: config.name,
+    description: config.description,
+    inputs: normalizedInputs,
+    schedule: {
+      cron: scheduleCron,
+      timezone: scheduleTimezone || "UTC",
+      preset: schedulePresetRef
+    }
+  };
+}
 function showPlanHelp() {
   console.log(`
 ${pc.dim("Usage:")}
@@ -349,22 +512,23 @@ function loadLocalAutomations(platformDir, filterName, appName) {
     }
     try {
       const configContent = readFileSync(configPath, "utf-8");
-      const config = JSON.parse(configContent);
-      if (filterName && config.external_id !== filterName && config.name !== filterName && entry.name !== filterName) {
+      const rawConfig = JSON.parse(configContent);
+      if (filterName && rawConfig.external_id !== filterName && rawConfig.name !== filterName && entry.name !== filterName) {
         continue;
       }
-      if (!config.external_id) {
+      if (!rawConfig.external_id) {
         if (appName) {
-          config.external_id = `${appName}:${entry.name}`;
+          rawConfig.external_id = `${appName}:${entry.name}`;
         } else {
           errors.push(`${entry.name}: missing external_id in config.json`);
           continue;
         }
       }
-      if (!config.name) {
+      if (!rawConfig.name) {
         errors.push(`${entry.name}: missing name in config.json`);
         continue;
       }
+      const config = normalizeLocalAutomation(rawConfig);
       if (!config.inputs?.schema) {
         errors.push(`${entry.name}: missing inputs.schema in config.json`);
         continue;
@@ -633,6 +797,15 @@ async function planAutomations(api, localAutomations) {
   const changes = [];
   const remoteAutomations = await api.listAutomations({ include_code: true });
   const remoteByExternalId = new Map(remoteAutomations.filter((a) => a.external_id).map((a) => [a.external_id, a]));
+  const remotePresetCache = /* @__PURE__ */ new Map();
+  const getRemotePresets = (automationId) => {
+    let cached = remotePresetCache.get(automationId);
+    if (!cached) {
+      cached = api.listPresets(automationId).catch(() => []);
+      remotePresetCache.set(automationId, cached);
+    }
+    return cached;
+  };
   for (const { automation, code } of localAutomations) {
     const remote = remoteByExternalId.get(automation.external_id);
     if (!remote) {
@@ -646,18 +819,31 @@ async function planAutomations(api, localAutomations) {
       const codeChanged = remote.code !== code;
       const nameChanged = remote.name !== automation.name;
       const descChanged = (remote.description || "") !== (automation.description || "");
-      const localSchema = automation.inputs?.schema ? JSON.stringify(automation.inputs.schema) : "";
-      const remoteSchema = remote.input_schema ? typeof remote.input_schema === "string" ? remote.input_schema : JSON.stringify(remote.input_schema) : "";
+      const localSchema = normalizeJsonComparable(automation.inputs?.schema);
+      const remoteSchema = normalizeJsonComparable(remote.input_schema);
       const schemaChanged = localSchema !== remoteSchema;
+      let remotePresets = [];
+      if (automation.inputs?.presets || automation.schedule || remote.schedule_preset_id) {
+        remotePresets = await getRemotePresets(remote.id);
+      }
+      const presetsChanged = automation.inputs?.presets ? comparisonMapsDiffer(
+        buildLocalPresetComparisonMap(automation.inputs.presets),
+        buildRemotePresetComparisonMap(remotePresets)
+      ) : false;
       const localCron = automation.schedule?.cron || "";
       const remoteCron = remote.schedule || "";
-      const scheduleChanged = localCron !== remoteCron;
-      if (codeChanged || nameChanged || descChanged || schemaChanged || scheduleChanged) {
+      const localTz = automation.schedule ? automation.schedule.timezone || "UTC" : "";
+      const remoteTz = remote.schedule ? remote.schedule_tz || "UTC" : "";
+      const localPresetName = automation.schedule ? resolveSchedulePresetName(automation.schedule, automation.inputs?.presets || {}) : "";
+      const remotePresetName = remote.schedule_preset_id ? remotePresets.find((preset) => preset.id === remote.schedule_preset_id)?.name || remote.schedule_preset_id : "";
+      const scheduleChanged = localCron !== remoteCron || localTz !== remoteTz || localPresetName !== remotePresetName;
+      if (codeChanged || nameChanged || descChanged || schemaChanged || presetsChanged || scheduleChanged) {
         const details = [];
         if (codeChanged) details.push("code");
         if (nameChanged) details.push("name");
         if (descChanged) details.push("description");
         if (schemaChanged) details.push("input_schema");
+        if (presetsChanged) details.push("presets");
         if (scheduleChanged) details.push("schedule");
         const textDiffs = [];
         if (codeChanged) {
@@ -839,7 +1025,7 @@ async function syncPresets(api, automationId, localPresets) {
   }
 }
 async function setSchedule(api, automationId, schedule, localPresets) {
-  const presetName = localPresets[schedule.preset]?.label || schedule.preset;
+  const presetName = resolveSchedulePresetName(schedule, localPresets);
   const remotePresets = await api.listPresets(automationId);
   const preset = remotePresets.find((p) => p.name === presetName);
   if (!preset) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lumerahq/cli",
-  "version": "0.18.0",
+  "version": "0.18.1",
   "description": "CLI for building and deploying Lumera apps",
   "type": "module",
   "engines": {