@lumerahq/cli 0.19.3-dev.0 → 0.19.4

package/dist/{resources-4IUZYKGX.js → resources-RHF2MDF7.js}

@@ -1,15 +1,16 @@
-import {
-  syncDeps
-} from "./chunk-XDTWVFPE.js";
 import {
   deploy
-} from "./chunk-53NOF33P.js";
+} from "./chunk-SU26C4GL.js";
+import {
+  projectResourceDepsEnabled,
+  syncDeps
+} from "./chunk-5T22627H.js";
 import {
   loadEnv
 } from "./chunk-2CR762KB.js";
 import {
   createApiClient
-} from "./chunk-GKI2HQJC.js";
+} from "./chunk-UH5X43VV.js";
 import {
   findProjectRoot,
   getApiUrl,
@@ -28,8 +29,95 @@ import "./chunk-PNKVD2UK.js";
 import pc2 from "picocolors";
 import prompts from "prompts";
 import { execFileSync, execSync } from "child_process";
-import { existsSync, readdirSync, readFileSync, writeFileSync, mkdirSync } from "fs";
-import { join, resolve } from "path";
+import { existsSync as existsSync2, readdirSync as readdirSync2, readFileSync as readFileSync2, writeFileSync, mkdirSync } from "fs";
+import { join as join2, resolve } from "path";
+
+// src/lib/lint/index.ts
+import { existsSync, readFileSync, readdirSync } from "fs";
+import { basename, join } from "path";
+
+// src/lib/lint/rules/collection-schema.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function error(target, message, snippet) {
+  return {
+    ruleId: "collection-schema",
+    target,
+    severity: "error",
+    message,
+    snippet
+  };
+}
+var collectionSchemaRule = {
+  id: "collection-schema",
+  description: "Validates local collection JSON files before planning or applying resources.",
+  appliesTo: ["collection"],
+  check(target) {
+    let parsed;
+    try {
+      parsed = JSON.parse(target.source);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return [error(target, `Invalid JSON: ${message}`)];
+    }
+    if (!isRecord(parsed)) {
+      return [error(target, "Collection file must contain a JSON object.")];
+    }
+    const issues = [];
+    const id = parsed.id;
+    const name = parsed.name;
+    const fields = parsed.fields;
+    const indexes = parsed.indexes;
+    if (typeof id !== "string" || id.trim() === "") {
+      issues.push(error(target, 'Missing required string field "id".'));
+    }
+    if (typeof name !== "string" || name.trim() === "") {
+      issues.push(error(target, 'Missing required string field "name".'));
+    } else {
+      if (/\s/.test(name)) {
+        issues.push(error(target, `Collection name "${name}" contains spaces; use underscores instead.`));
+      }
+      if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(name)) {
+        issues.push(error(target, `Collection name "${name}" contains invalid characters.`));
+      }
+    }
+    if (!Array.isArray(fields)) {
+      issues.push(error(target, 'Missing required array field "fields".'));
+    } else {
+      for (let i = 0; i < fields.length; i++) {
+        const field = fields[i];
+        if (!isRecord(field)) {
+          issues.push(error(target, `Field at index ${i} must be an object.`));
+          continue;
+        }
+        if (typeof field.name !== "string" || field.name.trim() === "") {
+          issues.push(error(target, `Field at index ${i} is missing required string field "name".`));
+        }
+        if (typeof field.type !== "string" || field.type.trim() === "") {
+          issues.push(error(target, `Field ${typeof field.name === "string" ? `"${field.name}"` : `at index ${i}`} is missing required string field "type".`));
+        }
+      }
+    }
+    if (indexes !== void 0) {
+      if (!Array.isArray(indexes)) {
+        issues.push(error(target, 'Optional field "indexes" must be an array when present.'));
+      } else {
+        for (let i = 0; i < indexes.length; i++) {
+          const index = indexes[i];
+          if (!isRecord(index)) {
+            issues.push(error(target, `Index at index ${i} must be an object.`));
+            continue;
+          }
+          if (!Array.isArray(index.fields) || !index.fields.every((field) => typeof field === "string" && field.trim() !== "")) {
+            issues.push(error(target, `Index at index ${i} must include a non-empty string array "fields".`));
+          }
+        }
+      }
+    }
+    return issues;
+  }
+};
 
 // src/lib/lint/rules/llm-import.ts
 var FROM_LUMERA_IMPORT_LLM = /^\s*from\s+lumera\s+import\s+\(?\s*(?:[\w\s,]*?\b)?llm\b/;
@@ -74,25 +162,37 @@ var llmImportRule = {
 };
 
 // src/lib/lint/registry.ts
-var ALL_RULES = [llmImportRule];
+var ALL_RULES = [collectionSchemaRule, llmImportRule];
 
 // src/lib/lint/format.ts
 import { relative } from "path";
 import pc from "picocolors";
 function printLintWarnings(warnings, projectRoot) {
   if (warnings.length === 0) return;
+  const errors = warnings.filter((w) => w.severity === "error");
+  const advisory = warnings.filter((w) => w.severity !== "error");
   console.log();
-  console.log(pc.bold("  Warnings:"));
+  console.log(pc.bold(errors.length > 0 ? "  Lint issues:" : "  Warnings:"));
   for (const w of warnings) {
     const rel = relative(projectRoot, w.target.filePath);
     const loc = w.line ? `${rel}:${w.line}` : rel;
-    console.log(`    ${pc.yellow("\u26A0")} ${loc}  ${pc.dim(`[${w.ruleId}]`)}`);
+    const isError = w.severity === "error";
+    const icon = isError ? pc.red("\u2717") : pc.yellow("\u26A0");
+    console.log(`    ${icon} ${loc}  ${pc.dim(`[${w.ruleId}]`)}`);
     console.log(`        ${w.message}`);
     if (w.snippet) console.log(pc.dim(`        > ${w.snippet}`));
   }
   console.log();
-  const n = warnings.length;
-  console.log(pc.dim(`  ${n} warning${n === 1 ? "" : "s"} \u2014 advisory, will not block apply.`));
+  if (errors.length > 0) {
+    const n = errors.length;
+    console.log(pc.red(`  ${n} error${n === 1 ? "" : "s"} \u2014 fix these before continuing.`));
+    if (advisory.length > 0) {
+      console.log(pc.dim(`  ${advisory.length} warning${advisory.length === 1 ? "" : "s"} \u2014 advisory.`));
+    }
+  } else {
+    const n = advisory.length;
+    console.log(pc.dim(`  ${n} warning${n === 1 ? "" : "s"} \u2014 advisory, will not block apply.`));
+  }
   console.log();
 }
 function serializeLintWarnings(warnings, projectRoot) {
@@ -100,6 +200,7 @@ function serializeLintWarnings(warnings, projectRoot) {
     ruleId: w.ruleId,
     target: { kind: w.target.kind, name: w.target.name, filePath: relative(projectRoot, w.target.filePath) },
     message: w.message,
+    severity: w.severity ?? "warning",
     line: w.line,
     snippet: w.snippet
   }));
@@ -130,6 +231,22 @@ function buildAutomationTargets(localAutomations) {
     source: a.code
   }));
 }
+function buildCollectionTargets(platformDir, _filterName) {
+  const collectionsDir = join(platformDir, "collections");
+  if (!existsSync(collectionsDir)) return [];
+  const targets = [];
+  for (const entry of readdirSync(collectionsDir, { withFileTypes: true })) {
+    if (!entry.isFile() || !entry.name.endsWith(".json")) continue;
+    const filePath = join(collectionsDir, entry.name);
+    targets.push({
+      kind: "collection",
+      name: basename(entry.name, ".json"),
+      filePath,
+      source: readFileSync(filePath, "utf-8")
+    });
+  }
+  return targets;
+}
 
 // src/commands/resources.ts
 init_auth();
@@ -148,82 +265,20 @@ function safePrintLint(warnings, projectRoot) {
     if (process.env.LUMERA_DEBUG) console.error("[lint] print failed:", err);
   }
 }
-var PACKAGE_MANAGERS = ["bun", "pnpm", "yarn", "npm"];
-var PACKAGE_MANAGER_VALUE_FLAGS = /* @__PURE__ */ new Set(["--package-manager"]);
-function isPackageManager(value) {
-  return PACKAGE_MANAGERS.includes(value);
+function lintCollectionFiles(projectRoot, platformDir, filterName) {
+  const issues = runLint({ projectRoot, targets: buildCollectionTargets(platformDir, filterName) });
+  const errors = issues.filter((issue) => issue.severity === "error");
+  if (errors.length === 0) return;
+  printLintWarnings(issues, projectRoot);
+  throw new Error(`Found ${errors.length} collection lint error(s)`);
 }
-function commandAvailable(command) {
-  try {
-    execFileSync(command, ["--version"], { stdio: "ignore" });
-    return true;
-  } catch {
-    return false;
-  }
-}
-function parsePackageManagerSpecifier(value) {
-  const raw = (value || "").trim();
-  if (!raw) return void 0;
-  const name = raw.split("@")[0];
-  return isPackageManager(name) ? name : void 0;
-}
-function packageManagerFromPackageJson(projectRoot) {
-  try {
-    const pkg = JSON.parse(readFileSync(join(projectRoot, "package.json"), "utf-8"));
-    return parsePackageManagerSpecifier(pkg.packageManager);
-  } catch {
-    return void 0;
-  }
-}
-function getFlagValue(args, name) {
-  const long = `--${name}`;
-  for (let i = 0; i < args.length; i++) {
-    const arg = args[i];
-    if (arg === long) {
-      const next = args[i + 1];
-      return next && !next.startsWith("-") ? next : void 0;
-    }
-    if (arg.startsWith(`${long}=`)) {
-      return arg.slice(long.length + 1);
-    }
-  }
-  return void 0;
-}
-function getPositionalArgs(args) {
-  const out = [];
-  for (let i = 0; i < args.length; i++) {
-    const arg = args[i];
-    if (PACKAGE_MANAGER_VALUE_FLAGS.has(arg)) {
-      i++;
-      continue;
+function detectPackageManager() {
+  for (const pm of ["bun", "pnpm", "yarn", "npm"]) {
+    try {
+      execFileSync(pm, ["--version"], { stdio: "ignore" });
+      return pm;
+    } catch {
     }
-    if (arg.startsWith("-")) continue;
-    out.push(arg);
-  }
-  return out;
-}
-function detectPackageManager(projectRoot, override) {
-  const requested = parsePackageManagerSpecifier(override || process.env.LUMERA_PACKAGE_MANAGER);
-  if (requested) {
-    if (!commandAvailable(requested)) {
-      throw new Error(`Package manager '${requested}' was requested but is not available on PATH`);
-    }
-    return requested;
-  }
-  const declared = packageManagerFromPackageJson(projectRoot);
-  if (declared && commandAvailable(declared)) return declared;
-  const lockfileManagers = [
-    { pm: "pnpm", file: "pnpm-lock.yaml" },
-    { pm: "bun", file: "bun.lockb" },
-    { pm: "bun", file: "bun.lock" },
-    { pm: "yarn", file: "yarn.lock" },
-    { pm: "npm", file: "package-lock.json" }
-  ];
-  for (const { pm, file } of lockfileManagers) {
-    if (existsSync(join(projectRoot, file)) && commandAvailable(pm)) return pm;
-  }
-  for (const pm of ["pnpm", "bun", "yarn", "npm"]) {
-    if (commandAvailable(pm)) return pm;
   }
   return "npm";
 }
@@ -503,9 +558,6 @@ ${pc2.dim("Resources:")}
 ${pc2.dim("Options:")}
   --yes, -y           Skip confirmation prompt (for CI/CD)
   --skip-build        Skip build step when applying app
-  --no-app            Apply resources only; do not build/deploy the app
-  --resources-only    Alias for --no-app
-  --package-manager   Package manager for app builds (pnpm, bun, yarn, npm)
 
 ${pc2.dim("Examples:")}
   lumera apply                       # Apply everything (shows plan, asks to confirm)
@@ -514,8 +566,6 @@ ${pc2.dim("Examples:")}
   lumera apply agents -y             # Apply agents without confirmation
   lumera apply app                   # Deploy frontend
   lumera apply app --skip-build      # Deploy without rebuilding
-  lumera apply --no-app -y           # Apply resources without app build/deploy
-  lumera apply app --package-manager pnpm
 `);
 }
 function showPullHelp() {
@@ -641,29 +691,29 @@ function parseResource(resourcePath) {
   return { type, name };
 }
 function getPlatformDir() {
-  if (existsSync(join(process.cwd(), "platform"))) {
-    return join(process.cwd(), "platform");
+  if (existsSync2(join2(process.cwd(), "platform"))) {
+    return join2(process.cwd(), "platform");
   }
-  if (existsSync(join(process.cwd(), "lumera_platform"))) {
-    return join(process.cwd(), "lumera_platform");
+  if (existsSync2(join2(process.cwd(), "lumera_platform"))) {
+    return join2(process.cwd(), "lumera_platform");
   }
-  return join(process.cwd(), "platform");
+  return join2(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)) {
+  const collectionsDir = join2(platformDir, "collections");
+  if (!existsSync2(collectionsDir)) {
     return [];
   }
   const collections = [];
   const errors = [];
-  for (const file of readdirSync(collectionsDir)) {
+  for (const file of readdirSync2(collectionsDir)) {
     if (!file.endsWith(".json")) continue;
-    const filePath = join(collectionsDir, file);
+    const filePath = join2(collectionsDir, file);
     try {
-      const content = readFileSync(filePath, "utf-8");
+      const content = readFileSync2(filePath, "utf-8");
       const collection = JSON.parse(content);
       if (filterName && collection.name !== filterName && collection.id !== filterName) {
         continue;
@@ -684,6 +734,27 @@ function loadLocalCollections(platformDir, filterName) {
         errors.push(`${file}: collection name "${collection.name}" contains invalid characters`);
         continue;
       }
+      if (!Array.isArray(collection.fields)) {
+        errors.push(`${file}: missing fields array`);
+        continue;
+      }
+      for (let i = 0; i < collection.fields.length; i++) {
+        const field = collection.fields[i];
+        if (!field || typeof field !== "object") {
+          errors.push(`${file}: field at index ${i} must be an object`);
+          continue;
+        }
+        if (typeof field.name !== "string" || field.name.trim() === "") {
+          errors.push(`${file}: field at index ${i} is missing name`);
+        }
+        if (typeof field.type !== "string" || field.type.trim() === "") {
+          errors.push(`${file}: field ${typeof field.name === "string" ? `"${field.name}"` : `at index ${i}`} is missing type`);
+        }
+      }
+      if (collection.indexes !== void 0 && !Array.isArray(collection.indexes)) {
+        errors.push(`${file}: indexes must be an array when present`);
+        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)`);
@@ -709,27 +780,27 @@ function loadLocalCollections(platformDir, filterName) {
   return collections;
 }
 function loadLocalAutomations(platformDir, filterName, appName) {
-  const automationsDir = join(platformDir, "automations");
-  if (!existsSync(automationsDir)) {
+  const automationsDir = join2(platformDir, "automations");
+  if (!existsSync2(automationsDir)) {
     return [];
   }
   const automations = [];
   const errors = [];
-  for (const entry of readdirSync(automationsDir, { withFileTypes: true })) {
+  for (const entry of readdirSync2(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)) {
+    const automationDir = join2(automationsDir, entry.name);
+    const configPath = join2(automationDir, "config.json");
+    const mainPath = join2(automationDir, "main.py");
+    if (!existsSync2(configPath)) {
       errors.push(`${entry.name}: missing config.json`);
       continue;
     }
-    if (!existsSync(mainPath)) {
+    if (!existsSync2(mainPath)) {
       errors.push(`${entry.name}: missing main.py`);
       continue;
     }
     try {
-      const configContent = readFileSync(configPath, "utf-8");
+      const configContent = readFileSync2(configPath, "utf-8");
       const rawConfig = JSON.parse(configContent);
       if (filterName && rawConfig.external_id !== filterName && rawConfig.name !== filterName && entry.name !== filterName) {
         continue;
@@ -756,7 +827,7 @@ function loadLocalAutomations(platformDir, filterName, appName) {
         errors.push(`${entry.name}: duplicate external_id "${config.external_id}" (also defined in ${existingByExtId.automation.name})`);
         continue;
       }
-      let code = readFileSync(mainPath, "utf-8");
+      let code = readFileSync2(mainPath, "utf-8");
       if (appName) {
         code = code.replaceAll("{{app}}", appName);
       }
@@ -775,15 +846,15 @@ function loadLocalAutomations(platformDir, filterName, appName) {
   return automations;
 }
 function loadLocalHooks(platformDir, filterName, appName) {
-  const hooksDir = join(platformDir, "hooks");
-  if (!existsSync(hooksDir)) {
+  const hooksDir = join2(platformDir, "hooks");
+  if (!existsSync2(hooksDir)) {
     return [];
   }
   const hooks = [];
-  for (const file of readdirSync(hooksDir)) {
+  for (const file of readdirSync2(hooksDir)) {
     if (!file.endsWith(".js") && !file.endsWith(".ts")) continue;
-    const filePath = join(hooksDir, file);
-    const content = readFileSync(filePath, "utf-8");
+    const filePath = join2(hooksDir, file);
+    const content = readFileSync2(filePath, "utf-8");
     const config = parseHookConfig(content);
     if (!config) {
       console.log(pc2.yellow(`  \u26A0 Skipping ${file}: could not parse config export`));
@@ -1099,12 +1170,12 @@ async function planAutomations(api, localAutomations) {
   return changes;
 }
 function loadLocalMailboxes(platformDir, filterName) {
-  const mailboxesDir = join(platformDir, "mailboxes");
-  if (!existsSync(mailboxesDir)) {
+  const mailboxesDir = join2(platformDir, "mailboxes");
+  if (!existsSync2(mailboxesDir)) {
     return [];
   }
   const mailboxes = [];
-  for (const file of readdirSync(mailboxesDir)) {
+  for (const file of readdirSync2(mailboxesDir)) {
     if (!file.endsWith(".json")) continue;
     const slug = file.replace(/\.json$/, "").trim();
     if (!slug) {
@@ -1114,10 +1185,10 @@ function loadLocalMailboxes(platformDir, filterName) {
     if (filterName && slug !== filterName) {
       continue;
     }
-    const filePath = join(mailboxesDir, file);
+    const filePath = join2(mailboxesDir, file);
     let raw;
     try {
-      raw = JSON.parse(readFileSync(filePath, "utf-8"));
+      raw = JSON.parse(readFileSync2(filePath, "utf-8"));
     } catch (e) {
       console.log(pc2.yellow(`  \u26A0 Skipping ${file}: invalid JSON (${e.message})`));
       continue;
@@ -1196,8 +1267,8 @@ async function pullMailboxes(api, platformDir, filterName) {
     console.log(pc2.dim("  (no mailboxes)"));
     return;
   }
-  const outDir = join(platformDir, "mailboxes");
-  if (!existsSync(outDir)) {
+  const outDir = join2(platformDir, "mailboxes");
+  if (!existsSync2(outDir)) {
     mkdirSync(outDir, { recursive: true });
   }
   let count = 0;
@@ -1205,7 +1276,7 @@ async function pullMailboxes(api, platformDir, filterName) {
     if (filterName && mb.slug !== filterName) continue;
     const body = {};
     if (mb.description) body.description = mb.description;
-    const file = join(outDir, `${toSafeFilename(mb.slug)}.json`);
+    const file = join2(outDir, `${toSafeFilename(mb.slug)}.json`);
     writeFileSync(file, JSON.stringify(body, null, 2) + "\n");
     console.log(pc2.green("  \u2713"), `pulled mailbox ${mb.slug} ${pc2.dim(`\u2192 ${file}`)}`);
     count++;
@@ -1464,7 +1535,7 @@ async function applyApp(args) {
   if (!skipBuild) {
     console.log(pc2.dim("  Building..."));
     try {
-      const pm = detectPackageManager(projectRoot, getFlagValue(args, "package-manager"));
+      const pm = detectPackageManager();
       execSync(`${pm} run build`, { cwd: projectRoot, stdio: "inherit" });
     } catch {
       throw new Error("Build failed");
@@ -1474,7 +1545,7 @@ async function applyApp(args) {
   await deploy({ token, appName, appTitle, distDir, apiUrl });
 }
 async function pullCollections(api, platformDir, filterName, appName) {
-  const collectionsDir = join(platformDir, "collections");
+  const collectionsDir = join2(platformDir, "collections");
   mkdirSync(collectionsDir, { recursive: true });
   const collections = await api.listCollections();
   for (const collection of collections) {
@@ -1518,13 +1589,13 @@ async function pullCollections(api, platformDir, filterName, appName) {
       }).filter((idx) => idx !== null)
     };
     const fileName = toSafeFilename(localName);
-    const filePath = join(collectionsDir, `${fileName}.json`);
+    const filePath = join2(collectionsDir, `${fileName}.json`);
     writeFileSync(filePath, JSON.stringify(localFormat, null, 2) + "\n");
     console.log(pc2.green("  \u2713"), `${localName} \u2192 collections/${fileName}.json`);
   }
 }
 async function pullAutomations(api, platformDir, filterName, projectId) {
-  const automationsDir = join(platformDir, "automations");
+  const automationsDir = join2(platformDir, "automations");
   mkdirSync(automationsDir, { recursive: true });
   const automations = await api.listAutomations({ include_code: true });
   for (const automation of automations) {
@@ -1535,7 +1606,7 @@ async function pullAutomations(api, platformDir, filterName, projectId) {
       continue;
     }
     const dirName = automation.external_id.replace(/[^a-zA-Z0-9_-]/g, "_");
-    const automationDir = join(automationsDir, dirName);
+    const automationDir = join2(automationsDir, dirName);
     mkdirSync(automationDir, { recursive: true });
     const config = {
       external_id: automation.external_id,
@@ -1568,13 +1639,13 @@ async function pullAutomations(api, platformDir, filterName, projectId) {
       }
     } catch {
     }
-    writeFileSync(join(automationDir, "config.json"), JSON.stringify(config, null, 2) + "\n");
-    writeFileSync(join(automationDir, "main.py"), automation.code || "");
+    writeFileSync(join2(automationDir, "config.json"), JSON.stringify(config, null, 2) + "\n");
+    writeFileSync(join2(automationDir, "main.py"), automation.code || "");
     console.log(pc2.green("  \u2713"), `${automation.name} \u2192 automations/${dirName}/`);
   }
 }
 async function pullHooks(api, platformDir, filterName, appName, projectId) {
-  const hooksDir = join(platformDir, "hooks");
+  const hooksDir = join2(platformDir, "hooks");
   mkdirSync(hooksDir, { recursive: true });
   const hooks = await api.listHooks();
   for (const hook of hooks) {
@@ -1596,31 +1667,31 @@ export default async function handler({ record, app, http }) {
 ${hook.script.split("\n").map((line) => "  " + line).join("\n")}
 }
 `;
-    writeFileSync(join(hooksDir, fileName), content);
+    writeFileSync(join2(hooksDir, fileName), content);
     console.log(pc2.green("  \u2713"), `${hook.name} \u2192 hooks/${fileName}`);
   }
 }
 function loadLocalAgents(platformDir, filterName, appName) {
-  const agentsDir = join(platformDir, "agents");
-  if (!existsSync(agentsDir)) return [];
+  const agentsDir = join2(platformDir, "agents");
+  if (!existsSync2(agentsDir)) return [];
   const agents = [];
   const errors = [];
-  for (const entry of readdirSync(agentsDir, { withFileTypes: true })) {
+  for (const entry of readdirSync2(agentsDir, { withFileTypes: true })) {
     if (!entry.isDirectory()) continue;
-    const agentDir = join(agentsDir, entry.name);
-    const configPath = join(agentDir, "config.json");
-    const promptPath = join(agentDir, "system_prompt.md");
-    const policyPath = join(agentDir, "policy.js");
-    if (!existsSync(configPath)) {
+    const agentDir = join2(agentsDir, entry.name);
+    const configPath = join2(agentDir, "config.json");
+    const promptPath = join2(agentDir, "system_prompt.md");
+    const policyPath = join2(agentDir, "policy.js");
+    if (!existsSync2(configPath)) {
       errors.push(`${entry.name}: missing config.json`);
       continue;
     }
-    if (!existsSync(promptPath)) {
+    if (!existsSync2(promptPath)) {
       errors.push(`${entry.name}: missing system_prompt.md`);
       continue;
     }
     try {
-      const config = JSON.parse(readFileSync(configPath, "utf-8"));
+      const config = JSON.parse(readFileSync2(configPath, "utf-8"));
       if (filterName && config.external_id !== filterName && config.name !== filterName && entry.name !== filterName) {
         continue;
       }
@@ -1643,8 +1714,8 @@ function loadLocalAgents(platformDir, filterName, appName) {
         errors.push(`${entry.name}: missing name in config.json`);
         continue;
       }
-      let systemPrompt = readFileSync(promptPath, "utf-8");
-      let policyScript = existsSync(policyPath) ? readFileSync(policyPath, "utf-8") : "";
+      let systemPrompt = readFileSync2(promptPath, "utf-8");
+      let policyScript = existsSync2(policyPath) ? readFileSync2(policyPath, "utf-8") : "";
       if (appName) {
         systemPrompt = systemPrompt.replaceAll("{{app}}", appName);
         policyScript = policyScript.replaceAll("{{app}}", appName);
@@ -1774,7 +1845,7 @@ async function applyAgents(api, localAgents, projectId) {
   return errors;
 }
 async function pullAgents(api, platformDir, filterName, projectId) {
-  const agentsDir = join(platformDir, "agents");
+  const agentsDir = join2(platformDir, "agents");
   mkdirSync(agentsDir, { recursive: true });
   const agents = await api.listAgents(projectId ? { project_id: projectId } : void 0);
   let skillIdToSlug = /* @__PURE__ */ new Map();
@@ -1789,7 +1860,7 @@ async function pullAgents(api, platformDir, filterName, projectId) {
       continue;
     }
     const dirName = agent.external_id.replace(/[^a-zA-Z0-9_-]/g, "_");
-    const agentDir = join(agentsDir, dirName);
+    const agentDir = join2(agentsDir, dirName);
     mkdirSync(agentDir, { recursive: true });
     const skillSlugs = [];
     if (agent.skill_ids) {
@@ -1806,10 +1877,10 @@ async function pullAgents(api, platformDir, filterName, projectId) {
     if (agent.model) config.model = agent.model;
     if (skillSlugs.length > 0) config.skills = skillSlugs;
     if (agent.policy_enabled) config.policy_enabled = true;
-    writeFileSync(join(agentDir, "config.json"), JSON.stringify(config, null, 2) + "\n");
-    writeFileSync(join(agentDir, "system_prompt.md"), agent.system_prompt || "");
+    writeFileSync(join2(agentDir, "config.json"), JSON.stringify(config, null, 2) + "\n");
+    writeFileSync(join2(agentDir, "system_prompt.md"), agent.system_prompt || "");
     if (agent.policy_script) {
-      writeFileSync(join(agentDir, "policy.js"), agent.policy_script);
+      writeFileSync(join2(agentDir, "policy.js"), agent.policy_script);
     }
     console.log(pc2.green("  \u2713"), `${agent.name} \u2192 agents/${dirName}/`);
   }
@@ -2447,7 +2518,10 @@ async function plan(args) {
   console.log(pc2.cyan(pc2.bold("  Plan")));
   console.log(pc2.dim("  Comparing local files to remote state..."));
   console.log();
-  await syncDeps(projectRoot);
+  if (!type || type === "collections") {
+    lintCollectionFiles(projectRoot, platformDir, name || void 0);
+  }
+  await syncDeps(projectRoot, { ignorePermissionDenied: true });
   const allChanges = [];
   let collections;
   try {
@@ -2568,13 +2642,9 @@ async function apply(args) {
   const appName = getAppName(projectRoot);
   const api = createApiClient(void 0, void 0, appName);
   const projectId = getProjectId(projectRoot);
-  const positionalArgs = getPositionalArgs(args);
+  const positionalArgs = args.filter((a) => !a.startsWith("-"));
   const { type, name } = parseResource(positionalArgs[0]);
   const autoConfirm = args.includes("--yes") || args.includes("-y") || !!process.env.CI;
-  const skipApp = args.includes("--no-app") || args.includes("--resources-only");
-  if (type === "app" && skipApp) {
-    throw new Error("Cannot combine app resource with --no-app / --resources-only");
-  }
   if (type === "app") {
     console.log();
     console.log(pc2.cyan(pc2.bold("  Apply")));
@@ -2586,7 +2656,10 @@ async function apply(args) {
     console.log();
     return;
   }
-  await syncDeps(projectRoot);
+  if (!type || type === "collections") {
+    lintCollectionFiles(projectRoot, platformDir, name || void 0);
+  }
+  await syncDeps(projectRoot, { ignorePermissionDenied: true });
   let collections;
   try {
     const remoteCollections = await api.listCollections();
@@ -2615,9 +2688,9 @@ async function apply(args) {
     }
   }
   let willDeployApp = false;
-  if (!type && !skipApp) {
+  if (!type) {
     try {
-      if (existsSync(join(projectRoot, "dist")) || existsSync(join(projectRoot, "src"))) {
+      if (existsSync2(join2(projectRoot, "dist")) || existsSync2(join2(projectRoot, "src"))) {
         willDeployApp = true;
       }
     } catch {
@@ -2795,6 +2868,11 @@ async function pull(args) {
     console.log(pc2.bold("  Collections:"));
     await pullCollections(api, platformDir, name || void 0, appName);
     console.log();
+    if (!name && await projectResourceDepsEnabled(projectRoot)) {
+      console.log(pc2.bold("  Resource shares:"));
+      await syncDeps(projectRoot, { write: true, legacyWhenDisabled: false, ignorePermissionDenied: true });
+      console.log();
+    }
   }
   if (!type || type === "automations") {
     console.log(pc2.bold("  Automations:"));