@lumerahq/cli 0.17.2 → 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-64MEBAL5.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-64MEBAL5.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-64MEBAL5.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-64MEBAL5.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-64MEBAL5.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-64MEBAL5.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-64MEBAL5.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-64MEBAL5.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:")}
@@ -252,8 +415,10 @@ function parseResource(resourcePath) {
   const parts = resourcePath.split("/");
   const type = parts[0];
   const name = parts.slice(1).join("/") || null;
-  if (!["collections", "automations", "hooks", "agents", "app"].includes(type)) {
-    return { type: null, name: null };
+  const validTypes = ["collections", "automations", "hooks", "agents", "app"];
+  if (!validTypes.includes(type)) {
+    console.log(pc.red(`  Unknown resource type "${type}". Valid types: ${validTypes.join(", ")}`));
+    process.exit(1);
   }
   return { type, name };
 }
@@ -301,6 +466,16 @@ function loadLocalCollections(platformDir, filterName) {
         errors.push(`${file}: collection name "${collection.name}" contains invalid characters`);
         continue;
       }
+      const existingById = collections.find((c) => c.id === collection.id);
+      if (existingById) {
+        errors.push(`${file}: duplicate collection id "${collection.id}" (also defined in another file)`);
+        continue;
+      }
+      const existingByName = collections.find((c) => c.name === collection.name);
+      if (existingByName) {
+        errors.push(`${file}: duplicate collection name "${collection.name}" (also defined in another file)`);
+        continue;
+      }
       collections.push(collection);
     } catch (e) {
       errors.push(`${file}: failed to parse - ${e}`);
@@ -337,26 +512,32 @@ 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;
       }
+      const existingByExtId = automations.find((a) => a.automation.external_id === config.external_id);
+      if (existingByExtId) {
+        errors.push(`${entry.name}: duplicate external_id "${config.external_id}" (also defined in ${existingByExtId.automation.name})`);
+        continue;
+      }
       const code = readFileSync(mainPath, "utf-8");
       automations.push({ automation: config, code });
     } catch (e) {
@@ -409,22 +590,28 @@ function loadLocalHooks(platformDir, filterName, appName) {
 function parseHookConfig(content) {
   const configMatch = content.match(/export\s+const\s+config\s*[=:]\s*(\{[\s\S]*?\});?/);
   if (!configMatch) return null;
-  try {
-    let configStr = configMatch[1].replace(/'/g, '"').replace(/(\w+):/g, '"$1":').replace(/,\s*}/g, "}");
-    return JSON.parse(configStr);
-  } catch {
-    const externalId = content.match(/external_id:\s*['"]([^'"]+)['"]/)?.[1];
-    const collection = content.match(/collection:\s*['"]([^'"]+)['"]/)?.[1];
-    const trigger = content.match(/trigger:\s*['"]([^'"]+)['"]/)?.[1];
-    const enabled = content.match(/enabled:\s*(true|false)/)?.[1];
-    if (!collection || !trigger) return null;
-    return {
-      external_id: externalId || "",
-      collection,
-      trigger,
-      enabled: enabled !== "false"
-    };
+  const externalId = configMatch[1].match(/external_id\s*:\s*['"]([^'"]+)['"]/)?.[1];
+  const collection = configMatch[1].match(/collection\s*:\s*['"]([^'"]+)['"]/)?.[1];
+  const trigger = configMatch[1].match(/trigger\s*:\s*['"]([^'"]+)['"]/)?.[1];
+  const enabled = configMatch[1].match(/enabled\s*:\s*(true|false)/)?.[1];
+  const name = configMatch[1].match(/name\s*:\s*['"]([^'"]+)['"]/)?.[1];
+  if (!collection || !trigger) return null;
+  const hook = {
+    external_id: externalId || "",
+    collection,
+    trigger,
+    enabled: enabled !== "false"
+  };
+  if (name) hook.name = name;
+  const metadataMatch = configMatch[1].match(/metadata\s*:\s*(\{[^}]*\})/);
+  if (metadataMatch) {
+    try {
+      const metaStr = metadataMatch[1].replace(/'/g, '"').replace(/(\w+)\s*:/g, '"$1":').replace(/,\s*}/g, "}");
+      hook.metadata = JSON.parse(metaStr);
+    } catch {
+    }
   }
+  return hook;
 }
 function extractHookScript(content) {
   const handlerMatch = content.match(
@@ -508,8 +695,37 @@ function fieldsDiffer(local, remote) {
     if (localMultiple && remoteMaxSelect <= 1) return true;
     if (!localMultiple && remoteMaxSelect > 1) return true;
   }
-  if (local.min !== void 0 && local.min !== opts.min) return true;
-  if (local.max !== void 0 && local.max !== opts.max) return true;
+  const localMin = local.min !== void 0 ? local.min : void 0;
+  const remoteMin = opts.min !== void 0 ? opts.min : void 0;
+  if (localMin !== remoteMin) return true;
+  const localMax = local.max !== void 0 ? local.max : void 0;
+  const remoteMax = opts.max !== void 0 ? opts.max : void 0;
+  if (localMax !== remoteMax) return true;
+  return false;
+}
+function localIndexesToSql(local) {
+  if (!local.indexes || local.indexes.length === 0) return [];
+  return local.indexes.map((idx) => {
+    const fields = idx.fields.join(", ");
+    const unique = idx.unique ? "UNIQUE " : "";
+    const indexName = `idx_${local.id}_${idx.fields.join("_")}`;
+    return `CREATE ${unique}INDEX ${indexName} ON ${local.name} (${fields})`;
+  }).sort();
+}
+function normalizeRemoteIndexes(remoteIndexes) {
+  return remoteIndexes.filter((idx) => {
+    const lower = idx.toLowerCase();
+    if (lower.includes("external_id") || lower.includes("updated")) return false;
+    return true;
+  }).sort();
+}
+function indexesDiffer(local, remoteIndexes) {
+  const localSql = localIndexesToSql(local);
+  const remoteSql = normalizeRemoteIndexes(remoteIndexes);
+  if (localSql.length !== remoteSql.length) return true;
+  for (let i = 0; i < localSql.length; i++) {
+    if (localSql[i] !== remoteSql[i]) return true;
+  }
   return false;
 }
 async function planCollections(api, localCollections) {
@@ -548,11 +764,13 @@ async function planCollections(api, localCollections) {
           modified.push(name);
         }
       }
-      if (added.length > 0 || removed.length > 0 || modified.length > 0) {
+      const indexesChanged = indexesDiffer(local, remote.indexes || []);
+      if (added.length > 0 || removed.length > 0 || modified.length > 0 || indexesChanged) {
         const details = [];
         if (added.length > 0) details.push(`+${added.length} field${added.length > 1 ? "s" : ""}`);
         if (removed.length > 0) details.push(`-${removed.length} field${removed.length > 1 ? "s" : ""}`);
         if (modified.length > 0) details.push(`~${modified.length} field${modified.length > 1 ? "s" : ""} (${modified.join(", ")})`);
+        if (indexesChanged) details.push("indexes changed");
         const fieldDetails = [];
         for (const name of added) {
           const f = localFieldMap.get(name);
@@ -579,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) {
@@ -592,11 +819,32 @@ async function planAutomations(api, localAutomations) {
       const codeChanged = remote.code !== code;
       const nameChanged = remote.name !== automation.name;
       const descChanged = (remote.description || "") !== (automation.description || "");
-      if (codeChanged || nameChanged || descChanged) {
+      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 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) {
           textDiffs.push({ field: "main.py", oldText: remote.code || "", newText: code });
@@ -635,10 +883,16 @@ async function planHooks(api, localHooks, collections) {
     } else {
       const scriptChanged = remote.script.trim() !== script.trim();
       const eventChanged = remote.event !== hook.trigger;
-      if (scriptChanged || eventChanged) {
+      const enabledChanged = remote.enabled !== void 0 && remote.enabled !== (hook.enabled !== false);
+      const nameChanged = hook.name && remote.name !== hook.name || false;
+      const collectionChanged = remote.collection_id !== collectionId;
+      if (scriptChanged || eventChanged || enabledChanged || nameChanged || collectionChanged) {
         const details = [];
         if (scriptChanged) details.push("script");
         if (eventChanged) details.push("trigger");
+        if (enabledChanged) details.push("enabled");
+        if (nameChanged) details.push("name");
+        if (collectionChanged) details.push("collection");
         const textDiffs = [];
         if (scriptChanged) {
           textDiffs.push({ field: fileName, oldText: remote.script || "", newText: script });
@@ -660,30 +914,25 @@ async function applyCollections(api, localCollections) {
   let errors = 0;
   const hasRelations = localCollections.some((c) => c.fields.some((f) => f.type === "relation"));
   if (hasRelations) {
+    const pass1Failed = /* @__PURE__ */ new Set();
     for (const local of localCollections) {
-      const relationFieldNames = new Set(local.fields.filter((f) => f.type === "relation").map((f) => f.name));
-      const withoutRelations = {
-        ...local,
-        fields: local.fields.filter((f) => f.type !== "relation"),
-        indexes: local.indexes?.filter((idx) => !idx.fields.some((f) => relationFieldNames.has(f)))
-      };
-      const apiFormat = convertCollectionToApiFormat(withoutRelations);
       try {
-        await api.ensureCollection(local.name, apiFormat);
+        await api.ensureCollection(local.name, { id: local.id });
         console.log(pc.green("  \u2713"), `${local.name}`);
       } catch (e) {
         console.log(pc.red("  \u2717"), `${local.name}: ${e}`);
+        pass1Failed.add(local.name);
         errors++;
       }
     }
-    const collectionsWithRelations = localCollections.filter((c) => c.fields.some((f) => f.type === "relation"));
-    for (const local of collectionsWithRelations) {
+    for (const local of localCollections) {
+      if (pass1Failed.has(local.name)) continue;
       const apiFormat = convertCollectionToApiFormat(local);
       try {
         await api.ensureCollection(local.name, apiFormat);
-        console.log(pc.green("  \u2713"), `${local.name} (relations)`);
+        console.log(pc.green("  \u2713"), `${local.name} (schema)`);
       } catch (e) {
-        console.log(pc.red("  \u2717"), `${local.name} (relations): ${e}`);
+        console.log(pc.red("  \u2717"), `${local.name} (schema): ${e}`);
         errors++;
       }
     }
@@ -746,6 +995,9 @@ async function applyAutomations(api, localAutomations) {
 async function syncPresets(api, automationId, localPresets) {
   const remotePresets = await api.listPresets(automationId);
   const remoteByName = new Map(remotePresets.map((p) => [p.name, p]));
+  const localPresetNames = new Set(
+    Object.entries(localPresets).map(([key, preset]) => preset.label || key)
+  );
   for (const [presetKey, preset] of Object.entries(localPresets)) {
     const presetName = preset.label || presetKey;
     const existing = remoteByName.get(presetName);
@@ -761,9 +1013,19 @@ async function syncPresets(api, automationId, localPresets) {
       console.log(pc.yellow(`    \u26A0 Failed to sync preset ${presetName}: ${e}`));
     }
   }
+  for (const remote of remotePresets) {
+    if (!localPresetNames.has(remote.name)) {
+      try {
+        await api.deletePreset(remote.id);
+        console.log(pc.dim(`    Deleted preset: ${remote.name}`));
+      } catch (e) {
+        console.log(pc.yellow(`    \u26A0 Failed to delete preset ${remote.name}: ${e}`));
+      }
+    }
+  }
 }
 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) {
@@ -1706,7 +1968,8 @@ async function plan(args) {
   const api = createApiClient();
   const appName = getAppName(projectRoot);
   const projectId = getProjectId(projectRoot);
-  const { type, name } = parseResource(args[0]);
+  const positionalArgs = args.filter((a) => !a.startsWith("-"));
+  const { type, name } = parseResource(positionalArgs[0]);
   console.log();
   console.log(pc.cyan(pc.bold("  Plan")));
   console.log(pc.dim("  Comparing local files to remote state..."));
@@ -1803,7 +2066,8 @@ async function apply(args) {
   const api = createApiClient();
   const appName = getAppName(projectRoot);
   const projectId = getProjectId(projectRoot);
-  const { type, name } = parseResource(args.filter((a) => a !== "--yes" && a !== "-y")[0]);
+  const positionalArgs = args.filter((a) => !a.startsWith("-"));
+  const { type, name } = parseResource(positionalArgs[0]);
   const autoConfirm = args.includes("--yes") || args.includes("-y") || !!process.env.CI;
   if (type === "app") {
     console.log();

package/package.json

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