@lumerahq/cli 0.7.0

package/dist/resources-PNK3NESI.js

@@ -0,0 +1,1350 @@
+import {
+  deploy
+} from "./chunk-AVKPM7C4.js";
+import {
+  createApiClient
+} from "./chunk-V2XXMMEI.js";
+import {
+  loadEnv
+} from "./chunk-2CR762KB.js";
+import {
+  getToken
+} from "./chunk-NDLYGKS6.js";
+import {
+  findProjectRoot,
+  getApiUrl,
+  getAppName,
+  getAppTitle
+} from "./chunk-D2BLSEGR.js";
+
+// src/commands/resources.ts
+import pc from "picocolors";
+import prompts from "prompts";
+import { existsSync, readdirSync, readFileSync, writeFileSync, mkdirSync } from "fs";
+import { join, resolve } from "path";
+function showPlanHelp() {
+  console.log(`
+${pc.dim("Usage:")}
+  lumera plan [resource]
+
+${pc.dim("Description:")}
+  Preview changes between local files and remote state.
+
+${pc.dim("Resources:")}
+  (none)              Plan all resources
+  collections         Plan only collections
+  collections/<name>  Plan single collection
+  automations         Plan only automations
+  automations/<name>  Plan single automation
+  hooks               Plan only hooks
+  app                 Plan app deployment
+
+${pc.dim("Examples:")}
+  lumera plan                        # Plan all resources
+  lumera plan collections            # Plan only collections
+  lumera plan automations/sync       # Plan single automation
+`);
+}
+function showApplyHelp() {
+  console.log(`
+${pc.dim("Usage:")}
+  lumera apply [resource]
+
+${pc.dim("Description:")}
+  Create or update resources from local files.
+
+${pc.dim("Resources:")}
+  (none)              Apply all resources
+  collections         Apply only collections
+  collections/<name>  Apply single collection
+  automations         Apply only automations
+  automations/<name>  Apply single automation
+  hooks               Apply only hooks
+  app                 Deploy the frontend app
+
+${pc.dim("Options:")}
+  --skip-build        Skip build step when applying app
+
+${pc.dim("Examples:")}
+  lumera apply                       # Apply everything
+  lumera apply collections           # Apply all collections
+  lumera apply collections/users     # Apply single collection
+  lumera apply app                   # Deploy frontend
+  lumera apply app --skip-build      # Deploy without rebuilding
+`);
+}
+function showPullHelp() {
+  console.log(`
+${pc.dim("Usage:")}
+  lumera pull [resource]
+
+${pc.dim("Description:")}
+  Download remote state to local files.
+
+${pc.dim("Resources:")}
+  (none)              Pull all resources
+  collections         Pull only collections
+  collections/<name>  Pull single collection
+  automations         Pull only automations
+  automations/<name>  Pull single automation
+  hooks               Pull only hooks
+
+${pc.dim("Examples:")}
+  lumera pull                        # Pull all resources
+  lumera pull collections            # Pull only collections
+  lumera pull automations/sync       # Pull single automation
+`);
+}
+function showDestroyHelp() {
+  console.log(`
+${pc.dim("Usage:")}
+  lumera destroy [resource]
+
+${pc.dim("Description:")}
+  Delete resources from remote.
+
+${pc.dim("Resources:")}
+  (none)              Destroy all resources
+  collections         Destroy only collections
+  collections/<name>  Destroy single collection
+  automations         Destroy only automations
+  automations/<name>  Destroy single automation
+  hooks               Destroy only hooks
+  app                 Delete app registration
+
+${pc.dim("Options:")}
+  --confirm           Skip confirmation prompt
+
+${pc.dim("Examples:")}
+  lumera destroy                     # Destroy everything
+  lumera destroy collections/users   # Destroy single collection
+  lumera destroy app                 # Delete app registration
+`);
+}
+function showListHelp() {
+  console.log(`
+${pc.dim("Usage:")}
+  lumera list [type]
+
+${pc.dim("Description:")}
+  List resources with status (synced, changed, local-only, remote-only).
+
+${pc.dim("Types:")}
+  (none)              List all resources
+  collections         List only collections
+  automations         List only automations
+  hooks               List only hooks
+
+${pc.dim("Examples:")}
+  lumera list                        # List all resources
+  lumera list collections            # List only collections
+`);
+}
+function showShowHelp() {
+  console.log(`
+${pc.dim("Usage:")}
+  lumera show <resource>
+
+${pc.dim("Description:")}
+  Show details of a single resource.
+
+${pc.dim("Resources:")}
+  collections/<name>  Show collection details
+  automations/<name>  Show automation details
+  hooks/<name>        Show hook details
+  app                 Show app details
+
+${pc.dim("Examples:")}
+  lumera show collections/users      # Show collection details
+  lumera show automations/sync       # Show automation details
+  lumera show app                    # Show app details
+`);
+}
+function parseResource(resourcePath) {
+  if (!resourcePath) {
+    return { type: null, name: null };
+  }
+  const parts = resourcePath.split("/");
+  const type = parts[0];
+  const name = parts.slice(1).join("/") || null;
+  if (!["collections", "automations", "hooks", "app"].includes(type)) {
+    return { type: null, name: null };
+  }
+  return { type, name };
+}
+function getPlatformDir() {
+  if (existsSync(join(process.cwd(), "platform"))) {
+    return join(process.cwd(), "platform");
+  }
+  if (existsSync(join(process.cwd(), "lumera_platform"))) {
+    return join(process.cwd(), "lumera_platform");
+  }
+  return join(process.cwd(), "platform");
+}
+function toSafeFilename(name) {
+  return name.replace(/\s+/g, "_").replace(/[^a-zA-Z0-9_-]/g, "").toLowerCase();
+}
+function loadLocalCollections(platformDir, filterName) {
+  const collectionsDir = join(platformDir, "collections");
+  if (!existsSync(collectionsDir)) {
+    return [];
+  }
+  const collections = [];
+  const errors = [];
+  for (const file of readdirSync(collectionsDir)) {
+    if (!file.endsWith(".json")) continue;
+    const filePath = join(collectionsDir, file);
+    try {
+      const content = readFileSync(filePath, "utf-8");
+      const collection = JSON.parse(content);
+      if (filterName && collection.name !== filterName && collection.id !== filterName) {
+        continue;
+      }
+      if (!collection.id) {
+        errors.push(`${file}: missing id field`);
+        continue;
+      }
+      if (!collection.name) {
+        errors.push(`${file}: missing name field`);
+        continue;
+      }
+      if (/\s/.test(collection.name)) {
+        errors.push(`${file}: collection name "${collection.name}" contains spaces - use underscores instead`);
+        continue;
+      }
+      if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(collection.name)) {
+        errors.push(`${file}: collection name "${collection.name}" contains invalid characters`);
+        continue;
+      }
+      collections.push(collection);
+    } catch (e) {
+      errors.push(`${file}: failed to parse - ${e}`);
+    }
+  }
+  if (errors.length > 0) {
+    console.log(pc.red("  Collection errors:"));
+    for (const err of errors) {
+      console.log(pc.red(`    \u2717 ${err}`));
+    }
+    throw new Error(`Found ${errors.length} collection error(s)`);
+  }
+  return collections;
+}
+function loadLocalAutomations(platformDir, filterName) {
+  const automationsDir = join(platformDir, "automations");
+  if (!existsSync(automationsDir)) {
+    return [];
+  }
+  const automations = [];
+  const errors = [];
+  for (const entry of readdirSync(automationsDir, { withFileTypes: true })) {
+    if (!entry.isDirectory()) continue;
+    const automationDir = join(automationsDir, entry.name);
+    const configPath = join(automationDir, "config.json");
+    const mainPath = join(automationDir, "main.py");
+    if (!existsSync(configPath)) {
+      errors.push(`${entry.name}: missing config.json`);
+      continue;
+    }
+    if (!existsSync(mainPath)) {
+      errors.push(`${entry.name}: missing main.py`);
+      continue;
+    }
+    try {
+      const configContent = readFileSync(configPath, "utf-8");
+      const config = JSON.parse(configContent);
+      if (filterName && config.external_id !== filterName && config.name !== filterName && entry.name !== filterName) {
+        continue;
+      }
+      if (!config.external_id) {
+        errors.push(`${entry.name}: missing external_id in config.json`);
+        continue;
+      }
+      if (!config.name) {
+        errors.push(`${entry.name}: missing name in config.json`);
+        continue;
+      }
+      if (!config.inputs?.schema) {
+        errors.push(`${entry.name}: missing inputs.schema in config.json`);
+        continue;
+      }
+      const code = readFileSync(mainPath, "utf-8");
+      automations.push({ automation: config, code });
+    } catch (e) {
+      errors.push(`${entry.name}: failed to parse config.json - ${e}`);
+    }
+  }
+  if (errors.length > 0) {
+    console.log(pc.red("  Automation errors:"));
+    for (const err of errors) {
+      console.log(pc.red(`    \u2717 ${err}`));
+    }
+    throw new Error(`Found ${errors.length} automation error(s)`);
+  }
+  return automations;
+}
+function loadLocalHooks(platformDir, filterName) {
+  const hooksDir = join(platformDir, "hooks");
+  if (!existsSync(hooksDir)) {
+    return [];
+  }
+  const hooks = [];
+  for (const file of readdirSync(hooksDir)) {
+    if (!file.endsWith(".js") && !file.endsWith(".ts")) continue;
+    const filePath = join(hooksDir, file);
+    const content = readFileSync(filePath, "utf-8");
+    const config = parseHookConfig(content);
+    if (!config) {
+      console.log(pc.yellow(`  \u26A0 Skipping ${file}: could not parse config export`));
+      continue;
+    }
+    if (!config.external_id) {
+      console.log(pc.yellow(`  \u26A0 Skipping ${file}: missing external_id in config`));
+      continue;
+    }
+    if (filterName && config.external_id !== filterName && file.replace(/\.(js|ts)$/, "") !== filterName) {
+      continue;
+    }
+    const script = extractHookScript(content);
+    hooks.push({ hook: config, script, fileName: file });
+  }
+  return hooks;
+}
+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 (!externalId || !collection || !trigger) return null;
+    return {
+      external_id: externalId,
+      collection,
+      trigger,
+      enabled: enabled !== "false"
+    };
+  }
+}
+function extractHookScript(content) {
+  const handlerMatch = content.match(
+    /export\s+default\s+(?:async\s+)?function\s*(?:\w+)?\s*\([^)]*\)\s*\{([\s\S]*)\}[\s\n]*$/
+  );
+  if (handlerMatch) {
+    return handlerMatch[1].trim();
+  }
+  const simpleMatch = content.match(
+    /export\s+default\s+async\s+function[^{]*\{([\s\S]*)\}[\s\n]*$/
+  );
+  if (simpleMatch) {
+    return simpleMatch[1].trim();
+  }
+  return content.replace(/export\s+const\s+config[\s\S]*?;/, "").trim();
+}
+function convertCollectionToApiFormat(local) {
+  const schema = local.fields.map((field) => {
+    const apiField = {
+      name: field.name,
+      type: mapFieldType(field.type),
+      required: field.required
+    };
+    const options = {};
+    if (field.type === "select" && field.values) {
+      options.values = field.values;
+      options.maxSelect = field.multiple ? field.values.length : 1;
+    }
+    if (field.type === "relation" && field.collection) {
+      options.collectionId = field.collection;
+      options.maxSelect = field.multiple ? 999 : 1;
+    }
+    if (field.max !== void 0) options.max = field.max;
+    if (field.min !== void 0) options.min = field.min;
+    if (Object.keys(options).length > 0) {
+      apiField.options = options;
+    }
+    return apiField;
+  });
+  const indexes = 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})`;
+  });
+  return { id: local.id, name: local.name, schema, indexes };
+}
+function mapFieldType(type) {
+  const typeMap = {
+    text: "text",
+    number: "number",
+    bool: "bool",
+    email: "text",
+    url: "text",
+    date: "date",
+    select: "select",
+    relation: "relation",
+    file: "lumera_file",
+    json: "json",
+    editor: "editor"
+  };
+  return typeMap[type] || type;
+}
+async function planCollections(api, localCollections) {
+  const changes = [];
+  const remoteCollections = await api.listCollections();
+  const remoteById = new Map(remoteCollections.map((c) => [c.id, c]));
+  for (const local of localCollections) {
+    const remote = remoteById.get(local.id);
+    if (!remote) {
+      changes.push({
+        type: "create",
+        resource: "collection",
+        id: local.id,
+        name: local.name,
+        details: `${local.fields.length} fields`
+      });
+    } else {
+      const localFieldNames = new Set(local.fields.map((f) => f.name));
+      const remoteFieldNames = new Set(remote.schema.map((f) => f.name));
+      const added = [...localFieldNames].filter((n) => !remoteFieldNames.has(n));
+      const removed = [...remoteFieldNames].filter((n) => !localFieldNames.has(n));
+      if (added.length > 0 || removed.length > 0) {
+        const details = [];
+        if (added.length > 0) details.push(`+${added.length} fields`);
+        if (removed.length > 0) details.push(`-${removed.length} fields`);
+        changes.push({
+          type: "update",
+          resource: "collection",
+          id: local.id,
+          name: local.name,
+          details: details.join(", ")
+        });
+      }
+    }
+  }
+  return changes;
+}
+async function planAutomations(api, localAutomations) {
+  const changes = [];
+  const remoteAutomations = await api.listAutomations();
+  const remoteByExternalId = new Map(remoteAutomations.filter((a) => a.external_id).map((a) => [a.external_id, a]));
+  for (const { automation, code } of localAutomations) {
+    const remote = remoteByExternalId.get(automation.external_id);
+    if (!remote) {
+      changes.push({
+        type: "create",
+        resource: "automation",
+        id: automation.external_id,
+        name: automation.name
+      });
+    } else {
+      const codeChanged = remote.code !== code;
+      const nameChanged = remote.name !== automation.name;
+      const descChanged = (remote.description || "") !== (automation.description || "");
+      if (codeChanged || nameChanged || descChanged) {
+        const details = [];
+        if (codeChanged) details.push("code");
+        if (nameChanged) details.push("name");
+        if (descChanged) details.push("description");
+        changes.push({
+          type: "update",
+          resource: "automation",
+          id: automation.external_id,
+          name: automation.name,
+          details: `changed: ${details.join(", ")}`
+        });
+      }
+    }
+  }
+  return changes;
+}
+async function planHooks(api, localHooks, collections) {
+  const changes = [];
+  const remoteHooks = await api.listHooks();
+  const remoteByExternalId = new Map(remoteHooks.filter((h) => h.external_id).map((h) => [h.external_id, h]));
+  for (const { hook, script, fileName } of localHooks) {
+    const remote = remoteByExternalId.get(hook.external_id);
+    const collectionId = collections.get(hook.collection);
+    if (!collectionId) {
+      console.log(pc.yellow(`  \u26A0 Skipping ${fileName}: collection '${hook.collection}' not found`));
+      continue;
+    }
+    if (!remote) {
+      changes.push({
+        type: "create",
+        resource: "hook",
+        id: hook.external_id,
+        name: `${hook.collection}.${hook.trigger}`
+      });
+    } else {
+      const scriptChanged = remote.script.trim() !== script.trim();
+      const eventChanged = remote.event !== hook.trigger;
+      if (scriptChanged || eventChanged) {
+        const details = [];
+        if (scriptChanged) details.push("script");
+        if (eventChanged) details.push("trigger");
+        changes.push({
+          type: "update",
+          resource: "hook",
+          id: hook.external_id,
+          name: `${hook.collection}.${hook.trigger}`,
+          details: `changed: ${details.join(", ")}`
+        });
+      }
+    }
+  }
+  return changes;
+}
+async function applyCollections(api, localCollections) {
+  for (const local of localCollections) {
+    const apiFormat = convertCollectionToApiFormat(local);
+    try {
+      await api.ensureCollection(local.name, apiFormat);
+      console.log(pc.green("  \u2713"), `${local.name}`);
+    } catch (e) {
+      console.log(pc.red("  \u2717"), `${local.name}: ${e}`);
+    }
+  }
+}
+async function applyAutomations(api, localAutomations) {
+  const remoteAutomations = await api.listAutomations();
+  const remoteByExternalId = new Map(remoteAutomations.filter((a) => a.external_id).map((a) => [a.external_id, a]));
+  for (const { automation, code } of localAutomations) {
+    const remote = remoteByExternalId.get(automation.external_id);
+    const payload = {
+      external_id: automation.external_id,
+      name: automation.name,
+      description: automation.description,
+      code
+    };
+    if (automation.inputs?.schema) {
+      payload.input_schema = automation.inputs.schema;
+    }
+    try {
+      let automationId;
+      if (remote) {
+        await api.updateAutomation(remote.id, payload);
+        automationId = remote.id;
+        console.log(pc.green("  \u2713"), `${automation.name} (updated)`);
+      } else {
+        const created = await api.createAutomation(payload);
+        automationId = created.id;
+        console.log(pc.green("  \u2713"), `${automation.name} (created)`);
+      }
+      if (automation.inputs?.presets) {
+        await syncPresets(api, automationId, automation.inputs.presets);
+      }
+      if (automation.schedule) {
+        await setSchedule(api, automationId, automation.schedule, automation.inputs?.presets || {});
+      } else if (remote?.schedule) {
+        await api.updateAutomation(automationId, { schedule: "", schedule_tz: "" });
+        console.log(pc.dim(`    Cleared schedule`));
+      }
+    } catch (e) {
+      console.log(pc.red("  \u2717"), `${automation.name}: ${e}`);
+    }
+  }
+}
+async function syncPresets(api, automationId, localPresets) {
+  const remotePresets = await api.listPresets(automationId);
+  const remoteByName = new Map(remotePresets.map((p) => [p.name, p]));
+  for (const [presetKey, preset] of Object.entries(localPresets)) {
+    const presetName = preset.label || presetKey;
+    const existing = remoteByName.get(presetName);
+    try {
+      if (existing) {
+        await api.updatePreset(existing.id, { name: presetName, inputs: preset.inputs });
+        console.log(pc.dim(`    Updated preset: ${presetName}`));
+      } else {
+        await api.createPreset(automationId, { name: presetName, inputs: preset.inputs });
+        console.log(pc.dim(`    Created preset: ${presetName}`));
+      }
+    } catch (e) {
+      console.log(pc.yellow(`    \u26A0 Failed to sync preset ${presetName}: ${e}`));
+    }
+  }
+}
+async function setSchedule(api, automationId, schedule, localPresets) {
+  const presetName = localPresets[schedule.preset]?.label || schedule.preset;
+  const remotePresets = await api.listPresets(automationId);
+  const preset = remotePresets.find((p) => p.name === presetName);
+  if (!preset) {
+    console.log(pc.yellow(`    \u26A0 Schedule preset '${schedule.preset}' not found, skipping schedule`));
+    return;
+  }
+  try {
+    await api.updateAutomation(automationId, {
+      schedule: schedule.cron,
+      schedule_tz: schedule.timezone || "UTC",
+      schedule_preset_id: preset.id
+    });
+    console.log(pc.dim(`    Set schedule: ${schedule.cron}`));
+  } catch (e) {
+    console.log(pc.yellow(`    \u26A0 Failed to set schedule: ${e}`));
+  }
+}
+async function applyHooks(api, localHooks, collections) {
+  const remoteHooks = await api.listHooks();
+  const remoteByExternalId = new Map(remoteHooks.filter((h) => h.external_id).map((h) => [h.external_id, h]));
+  for (const { hook, script, fileName } of localHooks) {
+    const remote = remoteByExternalId.get(hook.external_id);
+    const collectionId = collections.get(hook.collection);
+    if (!collectionId) {
+      console.log(pc.yellow(`  \u26A0 Skipping ${fileName}: collection '${hook.collection}' not found`));
+      continue;
+    }
+    const payload = {
+      external_id: hook.external_id,
+      collection_id: collectionId,
+      event: hook.trigger,
+      name: hook.name || `${hook.collection}.${hook.trigger}`,
+      script,
+      enabled: hook.enabled !== false,
+      metadata: hook.metadata
+    };
+    try {
+      if (remote) {
+        await api.updateHook(remote.id, payload);
+        console.log(pc.green("  \u2713"), `${payload.name} (updated)`);
+      } else {
+        await api.createHook(payload);
+        console.log(pc.green("  \u2713"), `${payload.name} (created)`);
+      }
+    } catch (e) {
+      console.log(pc.red("  \u2717"), `${payload.name}: ${e}`);
+    }
+  }
+}
+async function applyApp(args) {
+  const skipBuild = args.includes("--skip-build");
+  const projectRoot = findProjectRoot();
+  loadEnv(projectRoot);
+  const token = getToken(projectRoot);
+  const appName = getAppName(projectRoot);
+  const appTitle = getAppTitle(projectRoot);
+  const apiUrl = getApiUrl();
+  if (!skipBuild) {
+    console.log(pc.dim("  Building..."));
+    const { execSync } = await import("child_process");
+    try {
+      execSync("pnpm build", { cwd: projectRoot, stdio: "inherit" });
+    } catch {
+      throw new Error("Build failed");
+    }
+  }
+  const distDir = resolve(projectRoot, "dist");
+  await deploy({ token, appName, appTitle, distDir, apiUrl });
+}
+async function pullCollections(api, platformDir, filterName) {
+  const collectionsDir = join(platformDir, "collections");
+  mkdirSync(collectionsDir, { recursive: true });
+  const collections = await api.listCollections();
+  for (const collection of collections) {
+    if (collection.system || collection.managed) continue;
+    if (filterName && collection.name !== filterName && collection.id !== filterName) {
+      continue;
+    }
+    const localFormat = {
+      id: collection.id,
+      name: collection.name,
+      fields: collection.schema.map((field) => {
+        const localField = {
+          name: field.name,
+          type: field.type,
+          required: field.required
+        };
+        if (field.options) {
+          if (field.options.values) localField.values = field.options.values;
+          if (field.options.collectionId) localField.collection = field.options.collectionId;
+          if (field.options.maxSelect && field.options.maxSelect > 1) localField.multiple = true;
+        }
+        return localField;
+      }),
+      indexes: collection.indexes?.map((idx) => {
+        const match = idx.match(/CREATE\s+(UNIQUE\s+)?INDEX\s+\w+\s+ON\s+\w+\s+\(([^)]+)\)/i);
+        if (match) {
+          return { fields: match[2].split(",").map((f) => f.trim()), unique: !!match[1] };
+        }
+        return null;
+      }).filter((idx) => idx !== null)
+    };
+    const fileName = toSafeFilename(collection.name);
+    const filePath = join(collectionsDir, `${fileName}.json`);
+    writeFileSync(filePath, JSON.stringify(localFormat, null, 2) + "\n");
+    console.log(pc.green("  \u2713"), `${collection.name} \u2192 collections/${fileName}.json`);
+  }
+}
+async function pullAutomations(api, platformDir, filterName) {
+  const automationsDir = join(platformDir, "automations");
+  mkdirSync(automationsDir, { recursive: true });
+  const automations = await api.listAutomations();
+  for (const automation of automations) {
+    if (!automation.external_id || automation.managed) continue;
+    if (filterName && automation.external_id !== filterName && automation.name !== filterName) {
+      continue;
+    }
+    const dirName = automation.external_id.replace(/[^a-zA-Z0-9_-]/g, "_");
+    const automationDir = join(automationsDir, dirName);
+    mkdirSync(automationDir, { recursive: true });
+    const config = {
+      external_id: automation.external_id,
+      name: automation.name,
+      description: automation.description
+    };
+    if (automation.input_schema) {
+      try {
+        const schema = typeof automation.input_schema === "string" ? JSON.parse(automation.input_schema) : automation.input_schema;
+        config.inputs = { schema };
+      } catch {
+      }
+    }
+    try {
+      const presets = await api.listPresets(automation.id);
+      if (presets.length > 0) {
+        if (!config.inputs) config.inputs = {};
+        config.inputs.presets = {};
+        for (const preset of presets) {
+          const presetKey = preset.name.toLowerCase().replace(/\s+/g, "_").replace(/[^a-z0-9_]/g, "");
+          config.inputs.presets[presetKey] = { label: preset.name, inputs: preset.inputs };
+          if (automation.schedule && automation.schedule_preset_id === preset.id) {
+            config.schedule = {
+              cron: automation.schedule,
+              timezone: automation.schedule_tz || "UTC",
+              preset: presetKey
+            };
+          }
+        }
+      }
+    } catch {
+    }
+    writeFileSync(join(automationDir, "config.json"), JSON.stringify(config, null, 2) + "\n");
+    writeFileSync(join(automationDir, "main.py"), automation.code || "");
+    console.log(pc.green("  \u2713"), `${automation.name} \u2192 automations/${dirName}/`);
+  }
+}
+async function pullHooks(api, platformDir, filterName) {
+  const hooksDir = join(platformDir, "hooks");
+  mkdirSync(hooksDir, { recursive: true });
+  const hooks = await api.listHooks();
+  for (const hook of hooks) {
+    if (!hook.external_id) continue;
+    if (filterName && hook.external_id !== filterName) {
+      continue;
+    }
+    const fileName = `${hook.external_id.replace(/[^a-zA-Z0-9_-]/g, "_")}.js`;
+    const content = `export const config = {
+  external_id: '${hook.external_id}',
+  collection: '${hook.collection_name}',
+  trigger: '${hook.event}',
+  enabled: ${hook.enabled},
+};
+
+export default async function handler({ record, app, http }) {
+${hook.script.split("\n").map((line) => "  " + line).join("\n")}
+}
+`;
+    writeFileSync(join(hooksDir, fileName), content);
+    console.log(pc.green("  \u2713"), `${hook.name} \u2192 hooks/${fileName}`);
+  }
+}
+async function listResources(api, platformDir, filterType) {
+  const results = [];
+  if (!filterType || filterType === "collections") {
+    const localCollections = loadLocalCollections(platformDir);
+    const remoteCollections = await api.listCollections();
+    const remoteByName = new Map(remoteCollections.filter((c) => !c.system && !c.managed).map((c) => [c.name, c]));
+    const localNames = new Set(localCollections.map((c) => c.name));
+    for (const local of localCollections) {
+      const remote = remoteByName.get(local.name);
+      if (!remote) {
+        results.push({ name: local.name, type: "collections", status: "local-only" });
+      } else {
+        const localFieldNames = new Set(local.fields.map((f) => f.name));
+        const remoteFieldNames = new Set(remote.schema.map((f) => f.name));
+        const added = [...localFieldNames].filter((n) => !remoteFieldNames.has(n));
+        const removed = [...remoteFieldNames].filter((n) => !localFieldNames.has(n));
+        if (added.length > 0 || removed.length > 0) {
+          const details = [];
+          if (added.length > 0) details.push(`+${added.join(", ")}`);
+          if (removed.length > 0) details.push(`-${removed.join(", ")}`);
+          results.push({ name: local.name, type: "collections", status: "changed", details: details.join(" ") });
+        } else {
+          results.push({ name: local.name, type: "collections", status: "synced" });
+        }
+      }
+    }
+    for (const remote of remoteCollections) {
+      if (remote.system || remote.managed) continue;
+      if (!localNames.has(remote.name)) {
+        results.push({ name: remote.name, type: "collections", status: "remote-only" });
+      }
+    }
+  }
+  if (!filterType || filterType === "automations") {
+    const localAutomations = loadLocalAutomations(platformDir);
+    const remoteAutomations = await api.listAutomations();
+    const remoteByExternalId = new Map(remoteAutomations.filter((a) => a.external_id && !a.managed).map((a) => [a.external_id, a]));
+    const localIds = new Set(localAutomations.map((a) => a.automation.external_id));
+    for (const { automation, code } of localAutomations) {
+      const remote = remoteByExternalId.get(automation.external_id);
+      if (!remote) {
+        results.push({ name: automation.name, type: "automations", status: "local-only" });
+      } else {
+        const codeChanged = remote.code !== code;
+        const nameChanged = remote.name !== automation.name;
+        if (codeChanged || nameChanged) {
+          results.push({ name: automation.name, type: "automations", status: "changed", details: codeChanged ? "code" : "name" });
+        } else {
+          results.push({ name: automation.name, type: "automations", status: "synced" });
+        }
+      }
+    }
+    for (const remote of remoteAutomations) {
+      if (!remote.external_id || remote.managed) continue;
+      if (!localIds.has(remote.external_id)) {
+        results.push({ name: remote.name, type: "automations", status: "remote-only" });
+      }
+    }
+  }
+  if (!filterType || filterType === "hooks") {
+    const localHooks = loadLocalHooks(platformDir);
+    const remoteHooks = await api.listHooks();
+    const remoteByExternalId = new Map(remoteHooks.filter((h) => h.external_id).map((h) => [h.external_id, h]));
+    const localIds = new Set(localHooks.map((h) => h.hook.external_id));
+    for (const { hook, script } of localHooks) {
+      const remote = remoteByExternalId.get(hook.external_id);
+      if (!remote) {
+        results.push({ name: `${hook.collection}.${hook.trigger}`, type: "hooks", status: "local-only" });
+      } else {
+        const scriptChanged = remote.script.trim() !== script.trim();
+        if (scriptChanged) {
+          results.push({ name: `${hook.collection}.${hook.trigger}`, type: "hooks", status: "changed", details: "script" });
+        } else {
+          results.push({ name: `${hook.collection}.${hook.trigger}`, type: "hooks", status: "synced" });
+        }
+      }
+    }
+    for (const remote of remoteHooks) {
+      if (!remote.external_id) continue;
+      if (!localIds.has(remote.external_id)) {
+        results.push({ name: remote.name, type: "hooks", status: "remote-only" });
+      }
+    }
+  }
+  return results;
+}
+async function destroyResources(api, platformDir, resourceType, resourceName, skipConfirm) {
+  const toDelete = [];
+  if (!resourceType || resourceType === "collections") {
+    const localCollections = loadLocalCollections(platformDir, resourceName || void 0);
+    const remoteCollections = await api.listCollections();
+    const remoteByName = new Map(remoteCollections.map((c) => [c.name, c]));
+    for (const local of localCollections) {
+      const remote = remoteByName.get(local.name);
+      if (remote) {
+        toDelete.push({ type: "collection", id: local.id, name: local.name, remoteId: remote.id });
+      }
+    }
+  }
+  if (!resourceType || resourceType === "automations") {
+    try {
+      const localAutomations = loadLocalAutomations(platformDir, resourceName || void 0);
+      const remoteAutomations = await api.listAutomations();
+      const remoteByExternalId = new Map(remoteAutomations.filter((a) => a.external_id).map((a) => [a.external_id, a]));
+      for (const { automation } of localAutomations) {
+        const remote = remoteByExternalId.get(automation.external_id);
+        if (remote) {
+          toDelete.push({ type: "automation", id: automation.external_id, name: automation.name, remoteId: remote.id });
+        }
+      }
+    } catch {
+    }
+  }
+  if (!resourceType || resourceType === "hooks") {
+    const localHooks = loadLocalHooks(platformDir, resourceName || void 0);
+    const remoteHooks = await api.listHooks();
+    const remoteByExternalId = new Map(remoteHooks.filter((h) => h.external_id).map((h) => [h.external_id, h]));
+    for (const { hook } of localHooks) {
+      const remote = remoteByExternalId.get(hook.external_id);
+      if (remote) {
+        toDelete.push({ type: "hook", id: hook.external_id, name: `${hook.collection}.${hook.trigger}`, remoteId: remote.id });
+      }
+    }
+  }
+  if (toDelete.length === 0) {
+    console.log(pc.green("  \u2713 No resources found to delete"));
+    return;
+  }
+  console.log(pc.bold("  Resources to delete:"));
+  console.log();
+  for (const item of toDelete) {
+    console.log(pc.red(`    - ${item.type}: ${item.name}`));
+  }
+  console.log();
+  if (!skipConfirm) {
+    const { confirmed } = await prompts({
+      type: "confirm",
+      name: "confirmed",
+      message: `Delete ${toDelete.length} resource(s)?`,
+      initial: false
+    });
+    if (!confirmed) {
+      console.log(pc.dim("  Cancelled"));
+      return;
+    }
+  }
+  const hooks = toDelete.filter((r) => r.type === "hook");
+  const automations = toDelete.filter((r) => r.type === "automation");
+  const collections = toDelete.filter((r) => r.type === "collection");
+  for (const resource of hooks) {
+    try {
+      await api.deleteHook(resource.remoteId);
+      console.log(pc.green("  \u2713"), `Deleted hook: ${resource.name}`);
+    } catch (e) {
+      console.log(pc.red("  \u2717"), `Failed to delete hook ${resource.name}: ${e}`);
+    }
+  }
+  for (const resource of automations) {
+    try {
+      await api.deleteAutomation(resource.remoteId);
+      console.log(pc.green("  \u2713"), `Deleted automation: ${resource.name}`);
+    } catch (e) {
+      console.log(pc.red("  \u2717"), `Failed to delete automation ${resource.name}: ${e}`);
+    }
+  }
+  for (const resource of collections) {
+    try {
+      await api.deleteCollection(resource.remoteId);
+      console.log(pc.green("  \u2713"), `Deleted collection: ${resource.name}`);
+    } catch (e) {
+      console.log(pc.red("  \u2717"), `Failed to delete collection ${resource.name}: ${e}`);
+    }
+  }
+}
+async function destroyApp(skipConfirm) {
+  const projectRoot = findProjectRoot();
+  loadEnv(projectRoot);
+  const token = getToken(projectRoot);
+  const appName = getAppName(projectRoot);
+  let apiUrl = getApiUrl().replace(/\/+$/, "").replace(/\/api$/, "");
+  const filterParam = encodeURIComponent(JSON.stringify({ external_id: appName }));
+  const searchRes = await fetch(
+    `${apiUrl}/api/pb/collections/lm_custom_apps/records?filter=${filterParam}`,
+    { headers: { Authorization: `Bearer ${token}` } }
+  );
+  if (!searchRes.ok) {
+    throw new Error(`Failed to find app: ${await searchRes.text()}`);
+  }
+  const data = await searchRes.json();
+  const appRecord = data.items?.[0];
+  if (!appRecord) {
+    console.log(pc.yellow(`  App "${appName}" not found in Lumera.`));
+    return;
+  }
+  console.log(pc.dim(`  App to delete: ${appRecord.name} (${appRecord.external_id})`));
+  console.log();
+  if (!skipConfirm) {
+    const { confirmed } = await prompts({
+      type: "confirm",
+      name: "confirmed",
+      message: `Delete app "${appRecord.name}" from Lumera?`,
+      initial: false
+    });
+    if (!confirmed) {
+      console.log(pc.dim("  Cancelled"));
+      return;
+    }
+  }
+  const deleteRes = await fetch(
+    `${apiUrl}/api/pb/collections/lm_custom_apps/records/${appRecord.id}`,
+    { method: "DELETE", headers: { Authorization: `Bearer ${token}` } }
+  );
+  if (!deleteRes.ok) {
+    throw new Error(`Failed to delete app: ${await deleteRes.text()}`);
+  }
+  console.log(pc.green("  \u2713"), `App "${appRecord.name}" deleted from Lumera.`);
+}
+async function showResource(api, platformDir, resourceType, resourceName) {
+  if (resourceType === "collections") {
+    const localCollections = loadLocalCollections(platformDir, resourceName);
+    const remoteCollections = await api.listCollections();
+    const local = localCollections[0];
+    const remote = remoteCollections.find((c) => c.name === resourceName || c.id === resourceName);
+    if (!local && !remote) {
+      console.log(pc.red(`  Collection "${resourceName}" not found`));
+      process.exit(1);
+    }
+    console.log();
+    console.log(pc.bold(`  Collection: ${resourceName}`));
+    console.log();
+    if (local && remote) {
+      console.log(`  Status: ${pc.green("synced")}`);
+    } else if (local) {
+      console.log(`  Status: ${pc.yellow("local only")}`);
+    } else {
+      console.log(`  Status: ${pc.cyan("remote only")}`);
+    }
+    console.log();
+    const fields = local?.fields || remote?.schema || [];
+    console.log(pc.bold("  Fields:"));
+    for (const field of fields) {
+      const req = field.required ? pc.red("*") : "";
+      console.log(`    ${field.name}${req} ${pc.dim(`(${field.type})`)}`);
+    }
+    console.log();
+  } else if (resourceType === "automations") {
+    const localAutomations = loadLocalAutomations(platformDir, resourceName);
+    const remoteAutomations = await api.listAutomations();
+    const local = localAutomations[0];
+    const remote = remoteAutomations.find((a) => a.external_id === resourceName || a.name === resourceName);
+    if (!local && !remote) {
+      console.log(pc.red(`  Automation "${resourceName}" not found`));
+      process.exit(1);
+    }
+    console.log();
+    console.log(pc.bold(`  Automation: ${local?.automation.name || remote?.name}`));
+    console.log();
+    if (local && remote) {
+      console.log(`  Status: ${pc.green("synced")}`);
+    } else if (local) {
+      console.log(`  Status: ${pc.yellow("local only")}`);
+    } else {
+      console.log(`  Status: ${pc.cyan("remote only")}`);
+    }
+    if (local?.automation.description || remote?.description) {
+      console.log(`  Description: ${local?.automation.description || remote?.description}`);
+    }
+    console.log();
+  } else if (resourceType === "hooks") {
+    const localHooks = loadLocalHooks(platformDir, resourceName);
+    const remoteHooks = await api.listHooks();
+    const local = localHooks[0];
+    const remote = remoteHooks.find((h) => h.external_id === resourceName);
+    if (!local && !remote) {
+      console.log(pc.red(`  Hook "${resourceName}" not found`));
+      process.exit(1);
+    }
+    console.log();
+    console.log(pc.bold(`  Hook: ${local?.hook.external_id || remote?.external_id}`));
+    console.log();
+    console.log(`  Collection: ${local?.hook.collection || remote?.collection_name}`);
+    console.log(`  Trigger: ${local?.hook.trigger || remote?.event}`);
+    console.log(`  Enabled: ${local?.hook.enabled !== false || remote?.enabled}`);
+    console.log();
+  } else if (resourceType === "app") {
+    const projectRoot = findProjectRoot();
+    loadEnv(projectRoot);
+    const token = getToken(projectRoot);
+    const appName = getAppName(projectRoot);
+    const appTitle = getAppTitle(projectRoot);
+    let apiUrl = getApiUrl().replace(/\/+$/, "").replace(/\/api$/, "");
+    console.log();
+    console.log(pc.bold(`  App: ${appTitle || appName}`));
+    console.log();
+    console.log(`  External ID: ${appName}`);
+    const filterParam = encodeURIComponent(JSON.stringify({ external_id: appName }));
+    const searchRes = await fetch(
+      `${apiUrl}/api/pb/collections/lm_custom_apps/records?filter=${filterParam}`,
+      { headers: { Authorization: `Bearer ${token}` } }
+    );
+    if (searchRes.ok) {
+      const data = await searchRes.json();
+      const appRecord = data.items?.[0];
+      if (appRecord) {
+        console.log(`  Status: ${pc.green("deployed")}`);
+        if (appRecord.hosting_type) console.log(`  Hosting: ${appRecord.hosting_type}`);
+        if (appRecord.current_version) console.log(`  Version: ${appRecord.current_version}`);
+        if (appRecord.deployed_at) console.log(`  Deployed: ${appRecord.deployed_at}`);
+      } else {
+        console.log(`  Status: ${pc.yellow("not deployed")}`);
+      }
+    }
+    console.log();
+  }
+}
+async function plan(args) {
+  if (args.includes("--help") || args.includes("-h")) {
+    showPlanHelp();
+    return;
+  }
+  loadEnv();
+  const platformDir = getPlatformDir();
+  const api = createApiClient();
+  const { type, name } = parseResource(args[0]);
+  console.log();
+  console.log(pc.cyan(pc.bold("  Plan")));
+  console.log(pc.dim("  Comparing local files to remote state..."));
+  console.log();
+  const allChanges = [];
+  let collections;
+  try {
+    const remoteCollections = await api.listCollections();
+    collections = new Map(remoteCollections.map((c) => [c.name, c.id]));
+  } catch {
+    collections = /* @__PURE__ */ new Map();
+  }
+  if (!type || type === "collections") {
+    const localCollections = loadLocalCollections(platformDir, name || void 0);
+    if (localCollections.length > 0) {
+      const changes = await planCollections(api, localCollections);
+      allChanges.push(...changes);
+    }
+  }
+  if (!type || type === "automations") {
+    const localAutomations = loadLocalAutomations(platformDir, name || void 0);
+    if (localAutomations.length > 0) {
+      const changes = await planAutomations(api, localAutomations);
+      allChanges.push(...changes);
+    }
+  }
+  if (!type || type === "hooks") {
+    const localHooks = loadLocalHooks(platformDir, name || void 0);
+    if (localHooks.length > 0) {
+      const changes = await planHooks(api, localHooks, collections);
+      allChanges.push(...changes);
+    }
+  }
+  if (allChanges.length === 0) {
+    console.log(pc.green("  \u2713 No changes detected"));
+    console.log();
+    return;
+  }
+  console.log(pc.bold("  Changes:"));
+  console.log();
+  for (const change of allChanges) {
+    const icon = change.type === "create" ? "+" : change.type === "update" ? "~" : "-";
+    const color = change.type === "create" ? pc.green : change.type === "update" ? pc.yellow : pc.red;
+    const details = change.details ? ` (${change.details})` : "";
+    console.log(`  ${color(icon)} ${change.resource}: ${change.name}${pc.dim(details)}`);
+  }
+  console.log();
+  console.log(pc.dim(`  Run 'lumera apply' to apply these changes.`));
+  console.log();
+}
+async function apply(args) {
+  if (args.includes("--help") || args.includes("-h")) {
+    showApplyHelp();
+    return;
+  }
+  loadEnv();
+  const platformDir = getPlatformDir();
+  const api = createApiClient();
+  const { type, name } = parseResource(args[0]);
+  console.log();
+  console.log(pc.cyan(pc.bold("  Apply")));
+  console.log();
+  if (type === "app") {
+    console.log(pc.bold("  App:"));
+    await applyApp(args);
+    console.log();
+    console.log(pc.green("  Done!"));
+    console.log();
+    return;
+  }
+  let collections;
+  if (!type || type === "collections") {
+    const localCollections = loadLocalCollections(platformDir, name || void 0);
+    if (localCollections.length > 0) {
+      console.log(pc.bold("  Collections:"));
+      await applyCollections(api, localCollections);
+      console.log();
+    } else if (name) {
+      console.log(pc.red(`  Collection "${name}" not found locally`));
+      process.exit(1);
+    }
+  }
+  try {
+    const remoteCollections = await api.listCollections();
+    collections = new Map(remoteCollections.map((c) => [c.name, c.id]));
+    for (const c of remoteCollections) {
+      collections.set(c.id, c.id);
+    }
+  } catch {
+    collections = /* @__PURE__ */ new Map();
+  }
+  if (!type || type === "automations") {
+    const localAutomations = loadLocalAutomations(platformDir, name || void 0);
+    if (localAutomations.length > 0) {
+      console.log(pc.bold("  Automations:"));
+      await applyAutomations(api, localAutomations);
+      console.log();
+    } else if (name) {
+      console.log(pc.red(`  Automation "${name}" not found locally`));
+      process.exit(1);
+    }
+  }
+  if (!type || type === "hooks") {
+    const localHooks = loadLocalHooks(platformDir, name || void 0);
+    if (localHooks.length > 0) {
+      console.log(pc.bold("  Hooks:"));
+      await applyHooks(api, localHooks, collections);
+      console.log();
+    } else if (name) {
+      console.log(pc.red(`  Hook "${name}" not found locally`));
+      process.exit(1);
+    }
+  }
+  if (!type) {
+    try {
+      const projectRoot = findProjectRoot();
+      if (existsSync(join(projectRoot, "dist")) || existsSync(join(projectRoot, "src"))) {
+        console.log(pc.bold("  App:"));
+        await applyApp(args);
+        console.log();
+      }
+    } catch {
+    }
+  }
+  console.log(pc.green("  Done!"));
+  console.log();
+}
+async function pull(args) {
+  if (args.includes("--help") || args.includes("-h")) {
+    showPullHelp();
+    return;
+  }
+  loadEnv();
+  const platformDir = getPlatformDir();
+  const api = createApiClient();
+  const { type, name } = parseResource(args[0]);
+  console.log();
+  console.log(pc.cyan(pc.bold("  Pull")));
+  console.log(pc.dim(`  Downloading remote state to ${platformDir}/...`));
+  console.log();
+  if (!type || type === "collections") {
+    console.log(pc.bold("  Collections:"));
+    await pullCollections(api, platformDir, name || void 0);
+    console.log();
+  }
+  if (!type || type === "automations") {
+    console.log(pc.bold("  Automations:"));
+    await pullAutomations(api, platformDir, name || void 0);
+    console.log();
+  }
+  if (!type || type === "hooks") {
+    console.log(pc.bold("  Hooks:"));
+    await pullHooks(api, platformDir, name || void 0);
+    console.log();
+  }
+  console.log(pc.green("  Done!"));
+  console.log();
+}
+async function destroy(args) {
+  if (args.includes("--help") || args.includes("-h")) {
+    showDestroyHelp();
+    return;
+  }
+  loadEnv();
+  const platformDir = getPlatformDir();
+  const api = createApiClient();
+  const { type, name } = parseResource(args[0]);
+  const skipConfirm = args.includes("--confirm");
+  console.log();
+  console.log(pc.red(pc.bold("  Destroy")));
+  console.log();
+  if (type === "app") {
+    await destroyApp(skipConfirm);
+  } else {
+    await destroyResources(api, platformDir, type || void 0, name || void 0, skipConfirm);
+  }
+  console.log();
+}
+async function list(args) {
+  if (args.includes("--help") || args.includes("-h")) {
+    showListHelp();
+    return;
+  }
+  loadEnv();
+  const platformDir = getPlatformDir();
+  const api = createApiClient();
+  const filterType = args[0];
+  console.log();
+  console.log(pc.cyan(pc.bold("  Resources")));
+  console.log();
+  const resources = await listResources(api, platformDir, filterType);
+  if (resources.length === 0) {
+    console.log(pc.dim("  No resources found"));
+    console.log();
+    return;
+  }
+  const byType = /* @__PURE__ */ new Map();
+  for (const r of resources) {
+    if (!byType.has(r.type)) byType.set(r.type, []);
+    byType.get(r.type).push(r);
+  }
+  for (const [type, items] of byType) {
+    console.log(pc.bold(`  ${type.charAt(0).toUpperCase() + type.slice(1)}:`));
+    for (const item of items) {
+      let icon;
+      let color;
+      switch (item.status) {
+        case "synced":
+          icon = "\u2713";
+          color = pc.green;
+          break;
+        case "changed":
+          icon = "~";
+          color = pc.yellow;
+          break;
+        case "local-only":
+          icon = "+";
+          color = pc.cyan;
+          break;
+        case "remote-only":
+          icon = "?";
+          color = pc.dim;
+          break;
+      }
+      const details = item.details ? pc.dim(` (${item.details})`) : "";
+      console.log(`    ${color(icon)} ${item.name}${details}`);
+    }
+    console.log();
+  }
+  const synced = resources.filter((r) => r.status === "synced").length;
+  const changed = resources.filter((r) => r.status === "changed").length;
+  const localOnly = resources.filter((r) => r.status === "local-only").length;
+  const remoteOnly = resources.filter((r) => r.status === "remote-only").length;
+  const summary = [];
+  if (synced > 0) summary.push(pc.green(`${synced} synced`));
+  if (changed > 0) summary.push(pc.yellow(`${changed} changed`));
+  if (localOnly > 0) summary.push(pc.cyan(`${localOnly} local-only`));
+  if (remoteOnly > 0) summary.push(pc.dim(`${remoteOnly} remote-only`));
+  console.log(`  ${summary.join(" | ")}`);
+  console.log();
+}
+async function show(args) {
+  if (args.includes("--help") || args.includes("-h") || args.length === 0) {
+    showShowHelp();
+    if (args.length === 0) process.exit(1);
+    return;
+  }
+  loadEnv();
+  const platformDir = getPlatformDir();
+  const api = createApiClient();
+  const { type, name } = parseResource(args[0]);
+  if (!type) {
+    console.log(pc.red(`  Invalid resource path: ${args[0]}`));
+    console.log(pc.dim("  Use format: <type>/<name> (e.g., collections/users)"));
+    process.exit(1);
+  }
+  if (type === "app") {
+    await showResource(api, platformDir, "app", "");
+  } else if (!name) {
+    console.log(pc.red(`  Resource name required`));
+    console.log(pc.dim("  Use format: <type>/<name> (e.g., collections/users)"));
+    process.exit(1);
+  } else {
+    await showResource(api, platformDir, type, name);
+  }
+}
+export {
+  apply,
+  destroy,
+  list,
+  plan,
+  pull,
+  show
+};