@docyrus/docyrus 0.0.1 → 0.0.3

package/main.js

@@ -39952,7 +39952,7 @@ function buildInputSchema(args, env, options) {
 // package.json
 var package_default = {
   name: "@docyrus/docyrus",
-  version: "0.0.1",
+  version: "0.0.3",
   private: false,
   description: "Docyrus API CLI",
   main: "./main.js",
@@ -40428,6 +40428,8 @@ function createAuthCli(dependencies) {
 }
 
 // src/services/inputReader.ts
+var import_promises2 = require("node:fs/promises");
+var import_node_path4 = require("node:path");
 async function readStdinText() {
   if (process.stdin.isTTY) {
     return "";
@@ -40451,20 +40453,99 @@ function parseJsonData(raw, source) {
     });
   }
 }
-async function readJsonInput(params) {
-  const { data, readStdin = readStdinText } = params;
-  let rawJson = data?.trim();
-  if (!rawJson) {
-    rawJson = (await readStdin()).trim();
+function parseCsvRow(line) {
+  const values = [];
+  let current = "";
+  let inQuotes = false;
+  for (let index = 0; index < line.length; index += 1) {
+    const char = line[index];
+    const next = line[index + 1];
+    if (char === '"') {
+      if (inQuotes && next === '"') {
+        current += '"';
+        index += 1;
+      } else {
+        inQuotes = !inQuotes;
+      }
+      continue;
+    }
+    if (char === "," && !inQuotes) {
+      values.push(current.trim());
+      current = "";
+      continue;
+    }
+    current += char;
   }
-  if (!rawJson) {
-    throw new UserInputError("JSON input is required. Provide --data or pipe JSON via stdin.");
+  if (inQuotes) {
+    throw new UserInputError("Invalid CSV. Unterminated quoted value detected.");
   }
-  const parsed = parseJsonData(rawJson, data ? "--data" : "stdin");
-  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
-    throw new UserInputError("Expected a JSON object.");
+  values.push(current.trim());
+  return values;
+}
+function parseCsvData(raw, source) {
+  const trimmed = raw.trim();
+  if (!trimmed) {
+    throw new UserInputError(`CSV input is empty in ${source}.`);
+  }
+  const lines = trimmed.split(/\r?\n/).map((line) => line.trim()).filter((line) => line.length > 0);
+  if (lines.length < 2) {
+    throw new UserInputError(`CSV input in ${source} must include a header row and at least one data row.`);
+  }
+  const header = parseCsvRow(lines[0]);
+  if (header.length === 0 || header.some((name) => name.length === 0)) {
+    throw new UserInputError(`CSV header in ${source} contains empty column names.`);
+  }
+  const records = [];
+  for (let rowIndex = 1; rowIndex < lines.length; rowIndex += 1) {
+    const rowValues = parseCsvRow(lines[rowIndex]);
+    if (rowValues.length !== header.length) {
+      throw new UserInputError(
+        `CSV row ${rowIndex + 1} in ${source} has ${rowValues.length} values but header has ${header.length}.`
+      );
+    }
+    const record2 = {};
+    for (let columnIndex = 0; columnIndex < header.length; columnIndex += 1) {
+      record2[header[columnIndex]] = rowValues[columnIndex];
+    }
+    records.push(record2);
   }
-  return parsed;
+  return records;
+}
+async function readDataInput(params) {
+  const {
+    data,
+    fromFile,
+    readStdin = readStdinText,
+    readFileFn = async (path3, encoding) => await (0, import_promises2.readFile)(path3, encoding)
+  } = params;
+  const trimmedData = data?.trim();
+  const trimmedFromFile = fromFile?.trim();
+  if (trimmedData && trimmedFromFile) {
+    throw new UserInputError("Provide either --data or --from-file, not both.");
+  }
+  if (trimmedFromFile) {
+    let content;
+    try {
+      content = await readFileFn(trimmedFromFile, "utf8");
+    } catch (error48) {
+      throw new UserInputError(`Unable to read file '${trimmedFromFile}'.`, {
+        cause: error48
+      });
+    }
+    const extension = (0, import_node_path4.extname)(trimmedFromFile).toLowerCase();
+    if (extension === ".csv") {
+      return parseCsvData(content, "--from-file");
+    }
+    return parseJsonData(content, "--from-file");
+  }
+  if (trimmedData) {
+    return parseJsonData(trimmedData, "--data");
+  }
+  const stdinContent = (await readStdin()).trim();
+  if (!stdinContent) {
+    throw new UserInputError("JSON input is required. Provide --data, --from-file, or pipe JSON via stdin.");
+  }
+  return parseJsonData(stdinContent, "stdin");
 }
 
 // src/commands/curlCommand.ts
@@ -40610,6 +40691,42 @@ function createCurlCli(dependencies) {
 }
 
 // src/commands/dsCommands.ts
+var BULK_OPERATION_LIMIT = 50;
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function toBulkPayload(payload, mode) {
+  if (!Array.isArray(payload)) {
+    return null;
+  }
+  if (payload.length === 0) {
+    throw new UserInputError("Batch payload cannot be empty.");
+  }
+  if (payload.length > BULK_OPERATION_LIMIT) {
+    throw new UserInputError(`Batch payload cannot exceed ${BULK_OPERATION_LIMIT} items.`);
+  }
+  const records = [];
+  for (let index = 0; index < payload.length; index += 1) {
+    const item = payload[index];
+    if (!isRecord(item)) {
+      throw new UserInputError(`Batch item at index ${index} must be a JSON object.`);
+    }
+    if (mode === "update") {
+      const itemId = item.id;
+      if (itemId === void 0 || itemId === null || typeof itemId === "string" && itemId.trim().length === 0) {
+        throw new UserInputError(`Batch update item at index ${index} is missing required 'id'.`);
+      }
+    }
+    records.push(item);
+  }
+  return records;
+}
+function toSinglePayload(payload) {
+  if (!isRecord(payload)) {
+    throw new UserInputError("Expected a JSON object for single-item operation.");
+  }
+  return payload;
+}
 function createDsCli(dependencies) {
   const dsCli = Cli_exports.create("ds", {
     description: "Data source commands",
@@ -40683,16 +40800,25 @@ function createDsCli(dependencies) {
       dataSourceSlug: external_exports.string().min(1)
     }),
     options: external_exports.object({
-      data: external_exports.string().optional().describe("JSON payload for record fields")
+      data: external_exports.string().optional().describe("JSON payload for record fields"),
+      fromFile: external_exports.string().optional().describe("Path to JSON or CSV payload file")
     }),
     run: async (context) => {
       const apiBaseUrl = await dependencies.environmentConfigService.getActiveApiBaseUrl();
       const apiClient = dependencies.createApiClient(apiBaseUrl);
-      const payload = await readJsonInput({ data: context.options.data });
-      const response = await apiClient.request({
+      const payload = await readDataInput({
+        data: context.options.data,
+        fromFile: context.options.fromFile
+      });
+      const bulkPayload = toBulkPayload(payload, "create");
+      const response = bulkPayload ? await apiClient.request({
+        method: "POST",
+        path: `/apps/${context.args.appSlug}/data-sources/${context.args.dataSourceSlug}/items/bulk`,
+        body: bulkPayload
+      }) : await apiClient.request({
         method: "POST",
         path: `/apps/${context.args.appSlug}/data-sources/${context.args.dataSourceSlug}/items`,
-        body: payload
+        body: toSinglePayload(payload)
       });
       return await injectContext({
         apiBaseUrl,
@@ -40706,20 +40832,37 @@ function createDsCli(dependencies) {
     args: external_exports.object({
       appSlug: external_exports.string().min(1),
       dataSourceSlug: external_exports.string().min(1),
-      recordId: external_exports.string().min(1)
+      recordId: external_exports.string().min(1).optional()
     }),
     options: external_exports.object({
-      data: external_exports.string().optional().describe("JSON payload for record fields")
+      data: external_exports.string().optional().describe("JSON payload for record fields"),
+      fromFile: external_exports.string().optional().describe("Path to JSON or CSV payload file")
     }),
     run: async (context) => {
       const apiBaseUrl = await dependencies.environmentConfigService.getActiveApiBaseUrl();
       const apiClient = dependencies.createApiClient(apiBaseUrl);
-      const payload = await readJsonInput({ data: context.options.data });
-      const response = await apiClient.request({
-        method: "PATCH",
-        path: `/apps/${context.args.appSlug}/data-sources/${context.args.dataSourceSlug}/items/${context.args.recordId}`,
-        body: payload
+      const payload = await readDataInput({
+        data: context.options.data,
+        fromFile: context.options.fromFile
       });
+      const bulkPayload = toBulkPayload(payload, "update");
+      if (bulkPayload && context.args.recordId) {
+        throw new UserInputError("Do not provide recordId for batch update. Include 'id' in each item instead.");
+      }
+      const response = bulkPayload ? await apiClient.request({
+        method: "PATCH",
+        path: `/apps/${context.args.appSlug}/data-sources/${context.args.dataSourceSlug}/items/bulk`,
+        body: bulkPayload
+      }) : await (() => {
+        if (!context.args.recordId) {
+          throw new UserInputError("recordId is required for single-item update.");
+        }
+        return apiClient.request({
+          method: "PATCH",
+          path: `/apps/${context.args.appSlug}/data-sources/${context.args.dataSourceSlug}/items/${context.args.recordId}`,
+          body: toSinglePayload(payload)
+        });
+      })();
       return await injectContext({
         apiBaseUrl,
         authStore: dependencies.authStore,
@@ -40752,6 +40895,185 @@ function createDsCli(dependencies) {
 }
 
 // src/commands/discoverCommands.ts
+var import_promises3 = require("node:fs/promises");
+var SUPPORTED_HTTP_METHODS2 = [
+  "GET",
+  "POST",
+  "PUT",
+  "PATCH",
+  "DELETE",
+  "HEAD",
+  "OPTIONS",
+  "TRACE"
+];
+function isRecord2(value) {
+  return typeof value === "object" && value !== null;
+}
+function isEnoentError(error48) {
+  return typeof error48 === "object" && error48 !== null && "code" in error48 && error48.code === "ENOENT";
+}
+function normalizePathInput(pathValue) {
+  const trimmed = pathValue.trim();
+  if (!trimmed) {
+    throw new UserInputError("Path is required.");
+  }
+  return trimmed.startsWith("/") ? trimmed : `/${trimmed}`;
+}
+function buildPathCandidates(pathValue) {
+  const normalized = normalizePathInput(pathValue);
+  const candidates = /* @__PURE__ */ new Set([normalized]);
+  if (normalized === "/v1") {
+    candidates.add("/");
+  } else if (normalized.startsWith("/v1/")) {
+    candidates.add(normalized.substring(3));
+  } else {
+    candidates.add(`/v1${normalized}`);
+  }
+  return Array.from(candidates.values());
+}
+function toOutputPath(pathValue) {
+  const normalized = normalizePathInput(pathValue);
+  if (normalized === "/") {
+    return "/v1";
+  }
+  if (normalized.startsWith("/v1/") || normalized === "/v1") {
+    return normalized;
+  }
+  return `/v1${normalized}`;
+}
+function parseEndpointSelector(input) {
+  const trimmed = input.trim();
+  if (!trimmed) {
+    throw new UserInputError("Endpoint selector is required.");
+  }
+  const methodPathMatch = trimmed.match(/^\[([a-z]+)\](\/.*)$/i);
+  if (!methodPathMatch) {
+    return {
+      path: trimmed,
+      method: "GET"
+    };
+  }
+  return {
+    method: methodPathMatch[1].toUpperCase(),
+    path: methodPathMatch[2]
+  };
+}
+function getPaths(document) {
+  const rawPaths = document.paths;
+  return isRecord2(rawPaths) ? rawPaths : {};
+}
+function getEntities(document) {
+  const components = isRecord2(document.components) ? document.components : null;
+  if (components && isRecord2(components.schemas)) {
+    return components.schemas;
+  }
+  const definitions = document.definitions;
+  if (isRecord2(definitions)) {
+    return definitions;
+  }
+  return {};
+}
+function extractNamespaces(paths) {
+  const namespaces = /* @__PURE__ */ new Set();
+  for (const path3 of Object.keys(paths)) {
+    const segments = path3.split("/").map((item) => item.trim()).filter((item) => item.length > 0);
+    if (segments.length === 0) {
+      continue;
+    }
+    const namespace = segments[0] === "v1" ? segments[1] : segments[0];
+    if (namespace) {
+      namespaces.add(`/v1/${namespace}`);
+    }
+  }
+  return Array.from(namespaces.values()).sort((left, right) => left.localeCompare(right));
+}
+function getPathOperation(pathItem, method) {
+  if (!isRecord2(pathItem)) {
+    return null;
+  }
+  const normalizedMethod = method.toLowerCase();
+  const operation = pathItem[normalizedMethod];
+  return isRecord2(operation) ? operation : null;
+}
+function toEndpointMethodEntries(paths, pathFilter) {
+  const entries = [];
+  const sortedPaths = Object.keys(paths).filter(pathFilter).sort((left, right) => left.localeCompare(right));
+  for (const path3 of sortedPaths) {
+    const pathItem = paths[path3];
+    if (!isRecord2(pathItem)) {
+      continue;
+    }
+    for (const method of SUPPORTED_HTTP_METHODS2) {
+      const operation = getPathOperation(pathItem, method);
+      if (!operation) {
+        continue;
+      }
+      const descriptionValue = operation.description;
+      const summaryValue = operation.summary;
+      const description = typeof descriptionValue === "string" ? descriptionValue : typeof summaryValue === "string" ? summaryValue : void 0;
+      entries.push({
+        path: toOutputPath(path3),
+        method,
+        description
+      });
+    }
+  }
+  return entries;
+}
+function parseOpenApiDocument(raw) {
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (error48) {
+    throw new UserInputError("Stored OpenAPI spec is invalid JSON. Run 'docyrus discover api' to re-download.", {
+      cause: error48
+    });
+  }
+  if (!isRecord2(parsed)) {
+    throw new UserInputError("Stored OpenAPI spec must be a JSON object. Run 'docyrus discover api' to re-download.");
+  }
+  return parsed;
+}
+async function loadOpenApiSpec(dependencies, tenantId) {
+  let filePath = dependencies.tenantOpenApiService.getTenantOpenApiFilePath(tenantId);
+  let downloaded = false;
+  let sourceUrl;
+  let content;
+  try {
+    content = await (0, import_promises3.readFile)(filePath, "utf8");
+  } catch (error48) {
+    if (!isEnoentError(error48)) {
+      throw new UserInputError("Failed to read downloaded OpenAPI spec file.", {
+        filePath,
+        cause: error48
+      });
+    }
+    const downloadResult = await dependencies.tenantOpenApiService.downloadTenantOpenApi(tenantId);
+    downloaded = true;
+    sourceUrl = downloadResult.sourceUrl;
+    filePath = downloadResult.filePath;
+    content = await (0, import_promises3.readFile)(filePath, "utf8");
+  }
+  return {
+    filePath,
+    downloaded,
+    sourceUrl,
+    document: parseOpenApiDocument(content)
+  };
+}
+async function withActiveTenantSpec(dependencies) {
+  const apiBaseUrl = await dependencies.environmentConfigService.getActiveApiBaseUrl();
+  const activeProfile = await dependencies.authStore.getActiveProfile(apiBaseUrl);
+  if (!activeProfile) {
+    throw new AuthSessionError("No active session found. Run 'docyrus auth login'.");
+  }
+  const spec = await loadOpenApiSpec(dependencies, activeProfile.tenantId);
+  return {
+    apiBaseUrl,
+    activeProfile,
+    spec
+  };
+}
 function createDiscoverCli(dependencies) {
   const discoverCli = Cli_exports.create("discover", {
     description: "Discovery commands",
@@ -40778,6 +41100,154 @@ function createDiscoverCli(dependencies) {
       });
     }
   });
+  discoverCli.command("namespaces", {
+    description: "List API namespaces from active tenant OpenAPI spec",
+    run: async () => {
+      const { apiBaseUrl, spec } = await withActiveTenantSpec(dependencies);
+      const namespaces = extractNamespaces(getPaths(spec.document));
+      return await injectContext({
+        apiBaseUrl,
+        authStore: dependencies.authStore,
+        payload: {
+          namespaces,
+          count: namespaces.length,
+          specFilePath: spec.filePath,
+          downloaded: spec.downloaded,
+          sourceUrl: spec.sourceUrl
+        }
+      });
+    }
+  });
+  discoverCli.command("path", {
+    description: "List endpoints with method and description for matching path prefix",
+    args: external_exports.object({
+      prefix: external_exports.string().min(1).describe("Path prefix, e.g. /v1/users")
+    }),
+    run: async (context) => {
+      const { apiBaseUrl, spec } = await withActiveTenantSpec(dependencies);
+      const paths = getPaths(spec.document);
+      const candidates = buildPathCandidates(context.args.prefix);
+      const endpoints = toEndpointMethodEntries(
+        paths,
+        (path3) => candidates.some((candidate) => path3.startsWith(candidate))
+      );
+      return await injectContext({
+        apiBaseUrl,
+        authStore: dependencies.authStore,
+        payload: {
+          prefix: context.args.prefix,
+          normalizedPrefixes: candidates,
+          endpoints,
+          count: endpoints.length,
+          specFilePath: spec.filePath,
+          downloaded: spec.downloaded,
+          sourceUrl: spec.sourceUrl
+        }
+      });
+    }
+  });
+  discoverCli.command("endpoint", {
+    description: "Return full endpoint object for a path and HTTP method",
+    args: external_exports.object({
+      selector: external_exports.string().min(1).describe("Endpoint selector, e.g. /v1/users/me or [PUT]/v1/users/me/photo")
+    }),
+    run: async (context) => {
+      const { apiBaseUrl, spec } = await withActiveTenantSpec(dependencies);
+      const paths = getPaths(spec.document);
+      const selector = parseEndpointSelector(context.args.selector);
+      const candidates = buildPathCandidates(selector.path);
+      const resolvedPath = candidates.find((candidate) => candidate in paths);
+      if (!resolvedPath) {
+        throw new UserInputError(`Endpoint '${selector.path}' was not found in downloaded OpenAPI spec.`);
+      }
+      if (!SUPPORTED_HTTP_METHODS2.includes(selector.method)) {
+        throw new UserInputError(`Unsupported HTTP method '${selector.method}'.`);
+      }
+      const operation = getPathOperation(paths[resolvedPath], selector.method);
+      if (!operation) {
+        throw new UserInputError(
+          `Method '${selector.method}' is not available for endpoint '${toOutputPath(resolvedPath)}'.`
+        );
+      }
+      return await injectContext({
+        apiBaseUrl,
+        authStore: dependencies.authStore,
+        payload: {
+          requestedSelector: context.args.selector,
+          method: selector.method,
+          resolvedPath: toOutputPath(resolvedPath),
+          endpoint: operation,
+          specFilePath: spec.filePath,
+          downloaded: spec.downloaded,
+          sourceUrl: spec.sourceUrl
+        }
+      });
+    }
+  });
+  discoverCli.command("entity", {
+    description: "Return full entity object by name",
+    args: external_exports.object({
+      name: external_exports.string().min(1).describe("Entity name, e.g. UserEntity")
+    }),
+    run: async (context) => {
+      const { apiBaseUrl, spec } = await withActiveTenantSpec(dependencies);
+      const entities = getEntities(spec.document);
+      const requestedName = context.args.name.trim();
+      if (!(requestedName in entities)) {
+        throw new UserInputError(`Entity '${context.args.name}' was not found in downloaded OpenAPI spec.`);
+      }
+      return await injectContext({
+        apiBaseUrl,
+        authStore: dependencies.authStore,
+        payload: {
+          entityName: requestedName,
+          entity: entities[requestedName],
+          specFilePath: spec.filePath,
+          downloaded: spec.downloaded,
+          sourceUrl: spec.sourceUrl
+        }
+      });
+    }
+  });
+  discoverCli.command("search", {
+    description: "Search endpoint paths and entity names (endpoint results include method and description)",
+    args: external_exports.object({
+      query: external_exports.string().min(1).describe("One or more comma-separated search strings")
+    }),
+    run: async (context) => {
+      const { apiBaseUrl, spec } = await withActiveTenantSpec(dependencies);
+      const terms = context.args.query.split(",").map((term) => term.trim()).filter((term) => term.length > 0);
+      if (terms.length === 0) {
+        throw new UserInputError("Provide at least one non-empty search term.");
+      }
+      const entityNames = Object.keys(getEntities(spec.document));
+      const pathMap = getPaths(spec.document);
+      const results = terms.map((term) => {
+        const loweredTerm = term.toLowerCase();
+        const matchingEndpoints = toEndpointMethodEntries(
+          pathMap,
+          (path3) => path3.toLowerCase().includes(loweredTerm)
+        );
+        const matchingEntities = entityNames.filter((entityName) => entityName.toLowerCase().includes(loweredTerm));
+        return {
+          term,
+          endpoints: matchingEndpoints,
+          entityNames: matchingEntities.sort((left, right) => left.localeCompare(right))
+        };
+      });
+      return await injectContext({
+        apiBaseUrl,
+        authStore: dependencies.authStore,
+        payload: {
+          terms,
+          results,
+          specFilePath: spec.filePath,
+          downloaded: spec.downloaded,
+          sourceUrl: spec.sourceUrl
+        }
+      });
+    }
+  });
   return discoverCli;
 }
 
@@ -40819,6 +41289,952 @@ function createEnvCli(dependencies) {
   return envCli;
 }
 
+// src/services/studioPayload.ts
+var import_promises4 = require("node:fs/promises");
+var import_node_path5 = require("node:path");
+async function readStdinText2() {
+  if (process.stdin.isTTY) {
+    return "";
+  }
+  const chunks = [];
+  for await (const chunk of process.stdin) {
+    if (typeof chunk === "string") {
+      chunks.push(Buffer.from(chunk));
+    } else {
+      chunks.push(Buffer.from(chunk));
+    }
+  }
+  return Buffer.concat(chunks).toString("utf8").trim();
+}
+function isRecord3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+async function readStudioWriteInput(params) {
+  const {
+    data,
+    fromFile,
+    readStdin = readStdinText2,
+    readFileFn = async (path3, encoding) => await (0, import_promises4.readFile)(path3, encoding)
+  } = params;
+  const trimmedData = data?.trim();
+  const trimmedFromFile = fromFile?.trim();
+  if (trimmedData && trimmedFromFile) {
+    throw new UserInputError("Provide either --data or --from-file, not both.");
+  }
+  if (trimmedFromFile) {
+    const extension = (0, import_node_path5.extname)(trimmedFromFile).toLowerCase();
+    if (extension && extension !== ".json") {
+      throw new UserInputError("Studio commands support only JSON files in --from-file.");
+    }
+    let content;
+    try {
+      content = await readFileFn(trimmedFromFile, "utf8");
+    } catch (error48) {
+      throw new UserInputError(`Unable to read file '${trimmedFromFile}'.`, {
+        cause: error48
+      });
+    }
+    return parseJsonData(content, "--from-file");
+  }
+  if (trimmedData) {
+    return parseJsonData(trimmedData, "--data");
+  }
+  const stdinContent = (await readStdin()).trim();
+  if (!stdinContent) {
+    return {};
+  }
+  return parseJsonData(stdinContent, "stdin");
+}
+function ensureObjectPayload(payload, label) {
+  if (!isRecord3(payload)) {
+    throw new UserInputError(`${label} expects a JSON object payload.`);
+  }
+  return payload;
+}
+function mergeObjectWithFlags(basePayload, overrides) {
+  const merged = {
+    ...basePayload
+  };
+  for (const [key, value] of Object.entries(overrides)) {
+    if (value === void 0) {
+      continue;
+    }
+    merged[key] = value;
+  }
+  return merged;
+}
+function normalizeBatchPayload(payload, key) {
+  if (Array.isArray(payload)) {
+    return {
+      [key]: payload
+    };
+  }
+  if (isRecord3(payload)) {
+    if (key in payload) {
+      return payload;
+    }
+    if (Object.keys(payload).length === 0) {
+      throw new UserInputError(`Batch payload is required. Provide --data/--from-file with '${key}'.`);
+    }
+  }
+  throw new UserInputError(`Batch payload must be an array or object containing '${key}'.`);
+}
+
+// src/services/studioResolver.ts
+function isRecord4(value) {
+  return typeof value === "object" && value !== null;
+}
+function extractString(record2, key) {
+  const value = record2[key];
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function extractArray(payload) {
+  if (Array.isArray(payload)) {
+    return payload.filter((item) => isRecord4(item));
+  }
+  if (isRecord4(payload) && Array.isArray(payload.data)) {
+    return payload.data.filter((item) => isRecord4(item));
+  }
+  return [];
+}
+function ensureExclusiveSelector(label, idValue, slugValue) {
+  if (idValue && slugValue) {
+    throw new UserInputError(`Provide either --${label}Id or --${label}Slug, not both.`);
+  }
+  if (!idValue && !slugValue) {
+    throw new UserInputError(`Provide --${label}Id or --${label}Slug.`);
+  }
+}
+function normalizeOptional(value) {
+  const trimmed = value?.trim();
+  return trimmed && trimmed.length > 0 ? trimmed : void 0;
+}
+function resolveBySlug(label, items, slug) {
+  const matches = items.filter((item) => extractString(item, "slug") === slug);
+  if (matches.length === 0) {
+    throw new UserInputError(`${label} slug '${slug}' was not found.`);
+  }
+  if (matches.length > 1) {
+    const matchingIds = matches.map((item) => extractString(item, "id")).filter((id) => Boolean(id));
+    throw new UserInputError(`${label} slug '${slug}' is ambiguous. Matching IDs: ${matchingIds.join(", ")}`);
+  }
+  const matchId = extractString(matches[0], "id");
+  if (!matchId) {
+    throw new UserInputError(`${label} slug '${slug}' resolved to an invalid item without id.`);
+  }
+  return matchId;
+}
+var StudioResolver = class {
+  constructor(apiClient) {
+    this.apiClient = apiClient;
+  }
+  #appsCache = /* @__PURE__ */ new Map();
+  #dataSourcesByAppId = /* @__PURE__ */ new Map();
+  #fieldsByAppAndDataSource = /* @__PURE__ */ new Map();
+  async resolveAppId(options) {
+    const appId = normalizeOptional(options.appId);
+    const appSlug = normalizeOptional(options.appSlug);
+    ensureExclusiveSelector("app", appId, appSlug);
+    if (appId) {
+      return appId;
+    }
+    const apps = await this.#getApps();
+    return resolveBySlug("App", apps, appSlug);
+  }
+  async resolveDataSourceId(options) {
+    const dataSourceId = normalizeOptional(options.dataSourceId);
+    const dataSourceSlug = normalizeOptional(options.dataSourceSlug);
+    ensureExclusiveSelector("dataSource", dataSourceId, dataSourceSlug);
+    if (dataSourceId) {
+      return dataSourceId;
+    }
+    const dataSources = await this.getDataSourcesForApp(options.appId);
+    return resolveBySlug("Data source", dataSources, dataSourceSlug);
+  }
+  async resolveFieldId(options) {
+    const fieldId = normalizeOptional(options.fieldId);
+    const fieldSlug = normalizeOptional(options.fieldSlug);
+    ensureExclusiveSelector("field", fieldId, fieldSlug);
+    if (fieldId) {
+      return fieldId;
+    }
+    const fields = await this.getFieldsForDataSource(options.appId, options.dataSourceId);
+    return resolveBySlug("Field", fields, fieldSlug);
+  }
+  async getDataSourcesForApp(appId) {
+    const cacheKey = appId;
+    const cached2 = this.#dataSourcesByAppId.get(cacheKey);
+    if (cached2) {
+      return cached2;
+    }
+    const response = await this.apiClient.request({
+      method: "GET",
+      path: `/dev/apps/${appId}/data-sources`
+    });
+    const resolved = extractArray(response.data);
+    this.#dataSourcesByAppId.set(cacheKey, resolved);
+    return resolved;
+  }
+  async getFieldsForDataSource(appId, dataSourceId) {
+    const cacheKey = `${appId}::${dataSourceId}`;
+    const cached2 = this.#fieldsByAppAndDataSource.get(cacheKey);
+    if (cached2) {
+      return cached2;
+    }
+    const response = await this.apiClient.request({
+      method: "GET",
+      path: `/dev/apps/${appId}/data-sources/${dataSourceId}/fields`
+    });
+    const resolved = extractArray(response.data);
+    this.#fieldsByAppAndDataSource.set(cacheKey, resolved);
+    return resolved;
+  }
+  async #getApps() {
+    const cacheKey = "all";
+    const cached2 = this.#appsCache.get(cacheKey);
+    if (cached2) {
+      return cached2;
+    }
+    const response = await this.apiClient.request({
+      method: "GET",
+      path: "/dev/apps"
+    });
+    const resolved = extractArray(response.data);
+    this.#appsCache.set(cacheKey, resolved);
+    return resolved;
+  }
+};
+
+// src/commands/studioCommands.ts
+function parseOptionalJsonFlag(raw, source) {
+  if (!raw || raw.trim().length === 0) {
+    return void 0;
+  }
+  return parseJsonData(raw, source);
+}
+function wrapStudioPayload(apiBaseUrl, dependencies, payload) {
+  return injectContext({
+    apiBaseUrl,
+    authStore: dependencies.authStore,
+    payload
+  });
+}
+async function getStudioRunContext(dependencies) {
+  const apiBaseUrl = await dependencies.environmentConfigService.getActiveApiBaseUrl();
+  const apiClient = dependencies.createApiClient(apiBaseUrl);
+  const resolver = new StudioResolver(apiClient);
+  return {
+    apiBaseUrl,
+    apiClient,
+    resolver
+  };
+}
+function dataSourceFlags(options) {
+  return {
+    title: options.title,
+    name: options.name,
+    slug: options.slug,
+    type: options.type,
+    icon: options.icon,
+    data_sharing: options.dataSharing,
+    meta: parseOptionalJsonFlag(options.meta, "--meta")
+  };
+}
+function fieldFlags(options) {
+  return {
+    name: options.name,
+    slug: options.slug,
+    type: options.type,
+    read_only: options.readOnly,
+    status: options.status,
+    default_value: options.defaultValue,
+    relation_data_source_id: options.relationDataSourceId,
+    sort_order: options.sortOrder,
+    tenant_enum_set_id: options.tenantEnumSetId,
+    options: parseOptionalJsonFlag(options.options, "--options"),
+    validations: parseOptionalJsonFlag(options.validations, "--validations")
+  };
+}
+function requireNonEmptyObject(payload, label) {
+  if (Object.keys(payload).length === 0) {
+    throw new UserInputError(`${label} payload is empty. Provide flags, --data, or --from-file.`);
+  }
+}
+function createStudioCli(dependencies) {
+  const studioCli = Cli_exports.create("studio", {
+    description: "Studio (dev app data source CRUD) commands",
+    env: EnvSchema
+  });
+  studioCli.command("list-data-sources", {
+    description: "List data sources for an app",
+    options: external_exports.object({
+      appId: external_exports.string().optional().describe("App ID"),
+      appSlug: external_exports.string().optional().describe("App slug"),
+      expand: external_exports.string().optional().describe("Optional comma-separated expansions, e.g. fields")
+    }),
+    run: async (context) => {
+      const studio = await getStudioRunContext(dependencies);
+      const appId = await studio.resolver.resolveAppId({
+        appId: context.options.appId,
+        appSlug: context.options.appSlug
+      });
+      const response = await studio.apiClient.request({
+        method: "GET",
+        path: `/dev/apps/${appId}/data-sources`,
+        query: {
+          expand: context.options.expand
+        }
+      });
+      return await wrapStudioPayload(studio.apiBaseUrl, dependencies, response.data);
+    }
+  });
+  studioCli.command("get-data-source", {
+    description: "Get a single data source",
+    options: external_exports.object({
+      appId: external_exports.string().optional().describe("App ID"),
+      appSlug: external_exports.string().optional().describe("App slug"),
+      dataSourceId: external_exports.string().optional().describe("Data source ID"),
+      dataSourceSlug: external_exports.string().optional().describe("Data source slug")
+    }),
+    run: async (context) => {
+      const studio = await getStudioRunContext(dependencies);
+      const appId = await studio.resolver.resolveAppId({
+        appId: context.options.appId,
+        appSlug: context.options.appSlug
+      });
+      const dataSourceId = await studio.resolver.resolveDataSourceId({
+        appId,
+        dataSourceId: context.options.dataSourceId,
+        dataSourceSlug: context.options.dataSourceSlug
+      });
+      const response = await studio.apiClient.request({
+        method: "GET",
+        path: `/dev/apps/${appId}/data-sources/${dataSourceId}`
+      });
+      return await wrapStudioPayload(studio.apiBaseUrl, dependencies, response.data);
+    }
+  });
+  studioCli.command("create-data-source", {
+    description: "Create a data source",
+    options: external_exports.object({
+      appId: external_exports.string().optional().describe("App ID"),
+      appSlug: external_exports.string().optional().describe("App slug"),
+      data: external_exports.string().optional().describe("JSON payload"),
+      fromFile: external_exports.string().optional().describe("Path to JSON payload file"),
+      title: external_exports.string().optional().describe("Data source title"),
+      name: external_exports.string().optional().describe("Data source name"),
+      slug: external_exports.string().optional().describe("Data source slug"),
+      type: external_exports.string().optional().describe("Data source type"),
+      icon: external_exports.string().optional().describe("Icon"),
+      dataSharing: external_exports.string().optional().describe("Data sharing value"),
+      meta: external_exports.string().optional().describe("JSON meta payload")
+    }),
+    run: async (context) => {
+      const studio = await getStudioRunContext(dependencies);
+      const appId = await studio.resolver.resolveAppId({
+        appId: context.options.appId,
+        appSlug: context.options.appSlug
+      });
+      const basePayload = ensureObjectPayload(
+        await readStudioWriteInput({
+          data: context.options.data,
+          fromFile: context.options.fromFile
+        }),
+        "create-data-source"
+      );
+      const payload = mergeObjectWithFlags(basePayload, dataSourceFlags(context.options));
+      requireNonEmptyObject(payload, "create-data-source");
+      const response = await studio.apiClient.request({
+        method: "POST",
+        path: `/dev/apps/${appId}/data-sources`,
+        body: payload
+      });
+      return await wrapStudioPayload(studio.apiBaseUrl, dependencies, response.data);
+    }
+  });
+  studioCli.command("update-data-source", {
+    description: "Update a data source",
+    options: external_exports.object({
+      appId: external_exports.string().optional().describe("App ID"),
+      appSlug: external_exports.string().optional().describe("App slug"),
+      dataSourceId: external_exports.string().optional().describe("Data source ID"),
+      dataSourceSlug: external_exports.string().optional().describe("Data source slug"),
+      data: external_exports.string().optional().describe("JSON payload"),
+      fromFile: external_exports.string().optional().describe("Path to JSON payload file"),
+      title: external_exports.string().optional().describe("Data source title"),
+      name: external_exports.string().optional().describe("Data source name"),
+      slug: external_exports.string().optional().describe("Data source slug"),
+      type: external_exports.string().optional().describe("Data source type"),
+      icon: external_exports.string().optional().describe("Icon"),
+      dataSharing: external_exports.string().optional().describe("Data sharing value"),
+      meta: external_exports.string().optional().describe("JSON meta payload")
+    }),
+    run: async (context) => {
+      const studio = await getStudioRunContext(dependencies);
+      const appId = await studio.resolver.resolveAppId({
+        appId: context.options.appId,
+        appSlug: context.options.appSlug
+      });
+      const dataSourceId = await studio.resolver.resolveDataSourceId({
+        appId,
+        dataSourceId: context.options.dataSourceId,
+        dataSourceSlug: context.options.dataSourceSlug
+      });
+      const basePayload = ensureObjectPayload(
+        await readStudioWriteInput({
+          data: context.options.data,
+          fromFile: context.options.fromFile
+        }),
+        "update-data-source"
+      );
+      const payload = mergeObjectWithFlags(basePayload, dataSourceFlags(context.options));
+      requireNonEmptyObject(payload, "update-data-source");
+      const response = await studio.apiClient.request({
+        method: "PATCH",
+        path: `/dev/apps/${appId}/data-sources/${dataSourceId}`,
+        body: payload
+      });
+      return await wrapStudioPayload(studio.apiBaseUrl, dependencies, response.data);
+    }
+  });
+  studioCli.command("delete-data-source", {
+    description: "Delete a data source",
+    options: external_exports.object({
+      appId: external_exports.string().optional().describe("App ID"),
+      appSlug: external_exports.string().optional().describe("App slug"),
+      dataSourceId: external_exports.string().optional().describe("Data source ID"),
+      dataSourceSlug: external_exports.string().optional().describe("Data source slug")
+    }),
+    run: async (context) => {
+      const studio = await getStudioRunContext(dependencies);
+      const appId = await studio.resolver.resolveAppId({
+        appId: context.options.appId,
+        appSlug: context.options.appSlug
+      });
+      const dataSourceId = await studio.resolver.resolveDataSourceId({
+        appId,
+        dataSourceId: context.options.dataSourceId,
+        dataSourceSlug: context.options.dataSourceSlug
+      });
+      const response = await studio.apiClient.request({
+        method: "DELETE",
+        path: `/dev/apps/${appId}/data-sources/${dataSourceId}`
+      });
+      return await wrapStudioPayload(studio.apiBaseUrl, dependencies, response.data);
+    }
+  });
+  studioCli.command("bulk-create-data-sources", {
+    description: "Bulk create data sources",
+    options: external_exports.object({
+      appId: external_exports.string().optional().describe("App ID"),
+      appSlug: external_exports.string().optional().describe("App slug"),
+      data: external_exports.string().optional().describe("JSON payload"),
+      fromFile: external_exports.string().optional().describe("Path to JSON payload file")
+    }),
+    run: async (context) => {
+      const studio = await getStudioRunContext(dependencies);
+      const appId = await studio.resolver.resolveAppId({
+        appId: context.options.appId,
+        appSlug: context.options.appSlug
+      });
+      const batchPayload = normalizeBatchPayload(
+        await readStudioWriteInput({
+          data: context.options.data,
+          fromFile: context.options.fromFile
+        }),
+        "dataSources"
+      );
+      const response = await studio.apiClient.request({
+        method: "POST",
+        path: `/dev/apps/${appId}/data-sources/bulk`,
+        body: batchPayload
+      });
+      return await wrapStudioPayload(studio.apiBaseUrl, dependencies, response.data);
+    }
+  });
+  studioCli.command("list-fields", {
+    description: "List fields for a data source",
+    options: external_exports.object({
+      appId: external_exports.string().optional().describe("App ID"),
+      appSlug: external_exports.string().optional().describe("App slug"),
+      dataSourceId: external_exports.string().optional().describe("Data source ID"),
+      dataSourceSlug: external_exports.string().optional().describe("Data source slug")
+    }),
+    run: async (context) => {
+      const studio = await getStudioRunContext(dependencies);
+      const appId = await studio.resolver.resolveAppId({
+        appId: context.options.appId,
+        appSlug: context.options.appSlug
+      });
+      const dataSourceId = await studio.resolver.resolveDataSourceId({
+        appId,
+        dataSourceId: context.options.dataSourceId,
+        dataSourceSlug: context.options.dataSourceSlug
+      });
+      const response = await studio.apiClient.request({
+        method: "GET",
+        path: `/dev/apps/${appId}/data-sources/${dataSourceId}/fields`
+      });
+      return await wrapStudioPayload(studio.apiBaseUrl, dependencies, response.data);
+    }
+  });
+  studioCli.command("get-field", {
+    description: "Get a single field",
+    options: external_exports.object({
+      appId: external_exports.string().optional().describe("App ID"),
+      appSlug: external_exports.string().optional().describe("App slug"),
+      dataSourceId: external_exports.string().optional().describe("Data source ID"),
+      dataSourceSlug: external_exports.string().optional().describe("Data source slug"),
+      fieldId: external_exports.string().optional().describe("Field ID"),
+      fieldSlug: external_exports.string().optional().describe("Field slug")
+    }),
+    run: async (context) => {
+      const studio = await getStudioRunContext(dependencies);
+      const appId = await studio.resolver.resolveAppId({
+        appId: context.options.appId,
+        appSlug: context.options.appSlug
+      });
+      const dataSourceId = await studio.resolver.resolveDataSourceId({
+        appId,
+        dataSourceId: context.options.dataSourceId,
+        dataSourceSlug: context.options.dataSourceSlug
+      });
+      const fieldId = await studio.resolver.resolveFieldId({
+        appId,
+        dataSourceId,
+        fieldId: context.options.fieldId,
+        fieldSlug: context.options.fieldSlug
+      });
+      const response = await studio.apiClient.request({
+        method: "GET",
+        path: `/dev/apps/${appId}/data-sources/${dataSourceId}/fields/${fieldId}`
+      });
+      return await wrapStudioPayload(studio.apiBaseUrl, dependencies, response.data);
+    }
+  });
+  studioCli.command("create-field", {
+    description: "Create a field",
+    options: external_exports.object({
+      appId: external_exports.string().optional().describe("App ID"),
+      appSlug: external_exports.string().optional().describe("App slug"),
+      dataSourceId: external_exports.string().optional().describe("Data source ID"),
+      dataSourceSlug: external_exports.string().optional().describe("Data source slug"),
+      data: external_exports.string().optional().describe("JSON payload"),
+      fromFile: external_exports.string().optional().describe("Path to JSON payload file"),
+      name: external_exports.string().optional().describe("Field name"),
+      slug: external_exports.string().optional().describe("Field slug"),
+      type: external_exports.string().optional().describe("Field type"),
+      readOnly: external_exports.boolean().optional().describe("Field read only"),
+      status: external_exports.number().optional().describe("Field status"),
+      defaultValue: external_exports.string().optional().describe("Default value"),
+      relationDataSourceId: external_exports.string().optional().describe("Relation data source ID"),
+      sortOrder: external_exports.number().optional().describe("Sort order"),
+      tenantEnumSetId: external_exports.string().optional().describe("Tenant enum set ID"),
+      options: external_exports.string().optional().describe("JSON options"),
+      validations: external_exports.string().optional().describe("JSON validations")
+    }),
+    run: async (context) => {
+      const studio = await getStudioRunContext(dependencies);
+      const appId = await studio.resolver.resolveAppId({
+        appId: context.options.appId,
+        appSlug: context.options.appSlug
+      });
+      const dataSourceId = await studio.resolver.resolveDataSourceId({
+        appId,
+        dataSourceId: context.options.dataSourceId,
+        dataSourceSlug: context.options.dataSourceSlug
+      });
+      const basePayload = ensureObjectPayload(
+        await readStudioWriteInput({
+          data: context.options.data,
+          fromFile: context.options.fromFile
+        }),
+        "create-field"
+      );
+      const payload = mergeObjectWithFlags(basePayload, fieldFlags(context.options));
+      requireNonEmptyObject(payload, "create-field");
+      const response = await studio.apiClient.request({
+        method: "POST",
+        path: `/dev/apps/${appId}/data-sources/${dataSourceId}/fields`,
+        body: payload
+      });
+      return await wrapStudioPayload(studio.apiBaseUrl, dependencies, response.data);
+    }
+  });
+  studioCli.command("update-field", {
+    description: "Update a field",
+    options: external_exports.object({
+      appId: external_exports.string().optional().describe("App ID"),
+      appSlug: external_exports.string().optional().describe("App slug"),
+      dataSourceId: external_exports.string().optional().describe("Data source ID"),
+      dataSourceSlug: external_exports.string().optional().describe("Data source slug"),
+      fieldId: external_exports.string().optional().describe("Field ID"),
+      fieldSlug: external_exports.string().optional().describe("Field slug"),
+      data: external_exports.string().optional().describe("JSON payload"),
+      fromFile: external_exports.string().optional().describe("Path to JSON payload file"),
+      name: external_exports.string().optional().describe("Field name"),
+      slug: external_exports.string().optional().describe("Field slug"),
+      type: external_exports.string().optional().describe("Field type"),
+      readOnly: external_exports.boolean().optional().describe("Field read only"),
+      status: external_exports.number().optional().describe("Field status"),
+      defaultValue: external_exports.string().optional().describe("Default value"),
+      relationDataSourceId: external_exports.string().optional().describe("Relation data source ID"),
+      sortOrder: external_exports.number().optional().describe("Sort order"),
+      tenantEnumSetId: external_exports.string().optional().describe("Tenant enum set ID"),
+      options: external_exports.string().optional().describe("JSON options"),
+      validations: external_exports.string().optional().describe("JSON validations")
+    }),
+    run: async (context) => {
+      const studio = await getStudioRunContext(dependencies);
+      const appId = await studio.resolver.resolveAppId({
+        appId: context.options.appId,
+        appSlug: context.options.appSlug
+      });
+      const dataSourceId = await studio.resolver.resolveDataSourceId({
+        appId,
+        dataSourceId: context.options.dataSourceId,
+        dataSourceSlug: context.options.dataSourceSlug
+      });
+      const fieldId = await studio.resolver.resolveFieldId({
+        appId,
+        dataSourceId,
+        fieldId: context.options.fieldId,
+        fieldSlug: context.options.fieldSlug
+      });
+      const basePayload = ensureObjectPayload(
+        await readStudioWriteInput({
+          data: context.options.data,
+          fromFile: context.options.fromFile
+        }),
+        "update-field"
+      );
+      const payload = mergeObjectWithFlags(basePayload, fieldFlags(context.options));
+      requireNonEmptyObject(payload, "update-field");
+      const response = await studio.apiClient.request({
+        method: "PATCH",
+        path: `/dev/apps/${appId}/data-sources/${dataSourceId}/fields/${fieldId}`,
+        body: payload
+      });
+      return await wrapStudioPayload(studio.apiBaseUrl, dependencies, response.data);
+    }
+  });
+  studioCli.command("delete-field", {
+    description: "Delete a field",
+    options: external_exports.object({
+      appId: external_exports.string().optional().describe("App ID"),
+      appSlug: external_exports.string().optional().describe("App slug"),
+      dataSourceId: external_exports.string().optional().describe("Data source ID"),
+      dataSourceSlug: external_exports.string().optional().describe("Data source slug"),
+      fieldId: external_exports.string().optional().describe("Field ID"),
+      fieldSlug: external_exports.string().optional().describe("Field slug")
+    }),
+    run: async (context) => {
+      const studio = await getStudioRunContext(dependencies);
+      const appId = await studio.resolver.resolveAppId({
+        appId: context.options.appId,
+        appSlug: context.options.appSlug
+      });
+      const dataSourceId = await studio.resolver.resolveDataSourceId({
+        appId,
+        dataSourceId: context.options.dataSourceId,
+        dataSourceSlug: context.options.dataSourceSlug
+      });
+      const fieldId = await studio.resolver.resolveFieldId({
+        appId,
+        dataSourceId,
+        fieldId: context.options.fieldId,
+        fieldSlug: context.options.fieldSlug
+      });
+      const response = await studio.apiClient.request({
+        method: "DELETE",
+        path: `/dev/apps/${appId}/data-sources/${dataSourceId}/fields/${fieldId}`
+      });
+      return await wrapStudioPayload(studio.apiBaseUrl, dependencies, response.data);
+    }
+  });
+  studioCli.command("create-fields-batch", {
+    description: "Batch create fields",
+    options: external_exports.object({
+      appId: external_exports.string().optional().describe("App ID"),
+      appSlug: external_exports.string().optional().describe("App slug"),
+      dataSourceId: external_exports.string().optional().describe("Data source ID"),
+      dataSourceSlug: external_exports.string().optional().describe("Data source slug"),
+      data: external_exports.string().optional().describe("JSON payload"),
+      fromFile: external_exports.string().optional().describe("Path to JSON payload file")
+    }),
+    run: async (context) => {
+      const studio = await getStudioRunContext(dependencies);
+      const appId = await studio.resolver.resolveAppId({
+        appId: context.options.appId,
+        appSlug: context.options.appSlug
+      });
+      const dataSourceId = await studio.resolver.resolveDataSourceId({
+        appId,
+        dataSourceId: context.options.dataSourceId,
+        dataSourceSlug: context.options.dataSourceSlug
+      });
+      const payload = normalizeBatchPayload(
+        await readStudioWriteInput({
+          data: context.options.data,
+          fromFile: context.options.fromFile
+        }),
+        "fields"
+      );
+      const response = await studio.apiClient.request({
+        method: "POST",
+        path: `/dev/apps/${appId}/data-sources/${dataSourceId}/fields/batch`,
+        body: payload
+      });
+      return await wrapStudioPayload(studio.apiBaseUrl, dependencies, response.data);
+    }
+  });
+  studioCli.command("update-fields-batch", {
+    description: "Batch update fields",
+    options: external_exports.object({
+      appId: external_exports.string().optional().describe("App ID"),
+      appSlug: external_exports.string().optional().describe("App slug"),
+      dataSourceId: external_exports.string().optional().describe("Data source ID"),
+      dataSourceSlug: external_exports.string().optional().describe("Data source slug"),
+      data: external_exports.string().optional().describe("JSON payload"),
+      fromFile: external_exports.string().optional().describe("Path to JSON payload file")
+    }),
+    run: async (context) => {
+      const studio = await getStudioRunContext(dependencies);
+      const appId = await studio.resolver.resolveAppId({
+        appId: context.options.appId,
+        appSlug: context.options.appSlug
+      });
+      const dataSourceId = await studio.resolver.resolveDataSourceId({
+        appId,
+        dataSourceId: context.options.dataSourceId,
+        dataSourceSlug: context.options.dataSourceSlug
+      });
+      const payload = normalizeBatchPayload(
+        await readStudioWriteInput({
+          data: context.options.data,
+          fromFile: context.options.fromFile
+        }),
+        "fields"
+      );
+      const response = await studio.apiClient.request({
+        method: "PATCH",
+        path: `/dev/apps/${appId}/data-sources/${dataSourceId}/fields/batch`,
+        body: payload
+      });
+      return await wrapStudioPayload(studio.apiBaseUrl, dependencies, response.data);
+    }
+  });
+  studioCli.command("delete-fields-batch", {
+    description: "Batch delete fields",
+    options: external_exports.object({
+      appId: external_exports.string().optional().describe("App ID"),
+      appSlug: external_exports.string().optional().describe("App slug"),
+      dataSourceId: external_exports.string().optional().describe("Data source ID"),
+      dataSourceSlug: external_exports.string().optional().describe("Data source slug"),
+      data: external_exports.string().optional().describe("JSON payload"),
+      fromFile: external_exports.string().optional().describe("Path to JSON payload file")
+    }),
+    run: async (context) => {
+      const studio = await getStudioRunContext(dependencies);
+      const appId = await studio.resolver.resolveAppId({
+        appId: context.options.appId,
+        appSlug: context.options.appSlug
+      });
+      const dataSourceId = await studio.resolver.resolveDataSourceId({
+        appId,
+        dataSourceId: context.options.dataSourceId,
+        dataSourceSlug: context.options.dataSourceSlug
+      });
+      const payload = normalizeBatchPayload(
+        await readStudioWriteInput({
+          data: context.options.data,
+          fromFile: context.options.fromFile
+        }),
+        "fieldIds"
+      );
+      const response = await studio.apiClient.request({
+        method: "DELETE",
+        path: `/dev/apps/${appId}/data-sources/${dataSourceId}/fields/batch`,
+        body: payload
+      });
+      return await wrapStudioPayload(studio.apiBaseUrl, dependencies, response.data);
+    }
+  });
+  studioCli.command("list-enums", {
+    description: "List enums for a field",
+    options: external_exports.object({
+      appId: external_exports.string().optional().describe("App ID"),
+      appSlug: external_exports.string().optional().describe("App slug"),
+      dataSourceId: external_exports.string().optional().describe("Data source ID"),
+      dataSourceSlug: external_exports.string().optional().describe("Data source slug"),
+      fieldId: external_exports.string().optional().describe("Field ID"),
+      fieldSlug: external_exports.string().optional().describe("Field slug")
+    }),
+    run: async (context) => {
+      const studio = await getStudioRunContext(dependencies);
+      const appId = await studio.resolver.resolveAppId({
+        appId: context.options.appId,
+        appSlug: context.options.appSlug
+      });
+      const dataSourceId = await studio.resolver.resolveDataSourceId({
+        appId,
+        dataSourceId: context.options.dataSourceId,
+        dataSourceSlug: context.options.dataSourceSlug
+      });
+      const fieldId = await studio.resolver.resolveFieldId({
+        appId,
+        dataSourceId,
+        fieldId: context.options.fieldId,
+        fieldSlug: context.options.fieldSlug
+      });
+      const response = await studio.apiClient.request({
+        method: "GET",
+        path: `/dev/apps/${appId}/data-sources/${dataSourceId}/fields/${fieldId}/enums`
+      });
+      return await wrapStudioPayload(studio.apiBaseUrl, dependencies, response.data);
+    }
+  });
+  studioCli.command("create-enums", {
+    description: "Create enums for a field",
+    options: external_exports.object({
+      appId: external_exports.string().optional().describe("App ID"),
+      appSlug: external_exports.string().optional().describe("App slug"),
+      dataSourceId: external_exports.string().optional().describe("Data source ID"),
+      dataSourceSlug: external_exports.string().optional().describe("Data source slug"),
+      fieldId: external_exports.string().optional().describe("Field ID"),
+      fieldSlug: external_exports.string().optional().describe("Field slug"),
+      data: external_exports.string().optional().describe("JSON payload"),
+      fromFile: external_exports.string().optional().describe("Path to JSON payload file"),
+      enumSetId: external_exports.string().optional().describe("Enum set ID")
+    }),
+    run: async (context) => {
+      const studio = await getStudioRunContext(dependencies);
+      const appId = await studio.resolver.resolveAppId({
+        appId: context.options.appId,
+        appSlug: context.options.appSlug
+      });
+      const dataSourceId = await studio.resolver.resolveDataSourceId({
+        appId,
+        dataSourceId: context.options.dataSourceId,
+        dataSourceSlug: context.options.dataSourceSlug
+      });
+      const fieldId = await studio.resolver.resolveFieldId({
+        appId,
+        dataSourceId,
+        fieldId: context.options.fieldId,
+        fieldSlug: context.options.fieldSlug
+      });
+      const payload = mergeObjectWithFlags(
+        normalizeBatchPayload(
+          await readStudioWriteInput({
+            data: context.options.data,
+            fromFile: context.options.fromFile
+          }),
+          "enums"
+        ),
+        {
+          enumSetId: context.options.enumSetId
+        }
+      );
+      const response = await studio.apiClient.request({
+        method: "POST",
+        path: `/dev/apps/${appId}/data-sources/${dataSourceId}/fields/${fieldId}/enums`,
+        body: payload
+      });
+      return await wrapStudioPayload(studio.apiBaseUrl, dependencies, response.data);
+    }
+  });
+  studioCli.command("update-enums", {
+    description: "Update enums for a field",
+    options: external_exports.object({
+      appId: external_exports.string().optional().describe("App ID"),
+      appSlug: external_exports.string().optional().describe("App slug"),
+      dataSourceId: external_exports.string().optional().describe("Data source ID"),
+      dataSourceSlug: external_exports.string().optional().describe("Data source slug"),
+      fieldId: external_exports.string().optional().describe("Field ID"),
+      fieldSlug: external_exports.string().optional().describe("Field slug"),
+      data: external_exports.string().optional().describe("JSON payload"),
+      fromFile: external_exports.string().optional().describe("Path to JSON payload file")
+    }),
+    run: async (context) => {
+      const studio = await getStudioRunContext(dependencies);
+      const appId = await studio.resolver.resolveAppId({
+        appId: context.options.appId,
+        appSlug: context.options.appSlug
+      });
+      const dataSourceId = await studio.resolver.resolveDataSourceId({
+        appId,
+        dataSourceId: context.options.dataSourceId,
+        dataSourceSlug: context.options.dataSourceSlug
+      });
+      const fieldId = await studio.resolver.resolveFieldId({
+        appId,
+        dataSourceId,
+        fieldId: context.options.fieldId,
+        fieldSlug: context.options.fieldSlug
+      });
+      const payload = normalizeBatchPayload(
+        await readStudioWriteInput({
+          data: context.options.data,
+          fromFile: context.options.fromFile
+        }),
+        "enums"
+      );
+      const response = await studio.apiClient.request({
+        method: "PATCH",
+        path: `/dev/apps/${appId}/data-sources/${dataSourceId}/fields/${fieldId}/enums`,
+        body: payload
+      });
+      return await wrapStudioPayload(studio.apiBaseUrl, dependencies, response.data);
+    }
+  });
+  studioCli.command("delete-enums", {
+    description: "Delete enums for a field",
+    options: external_exports.object({
+      appId: external_exports.string().optional().describe("App ID"),
+      appSlug: external_exports.string().optional().describe("App slug"),
+      dataSourceId: external_exports.string().optional().describe("Data source ID"),
+      dataSourceSlug: external_exports.string().optional().describe("Data source slug"),
+      fieldId: external_exports.string().optional().describe("Field ID"),
+      fieldSlug: external_exports.string().optional().describe("Field slug"),
+      data: external_exports.string().optional().describe("JSON payload"),
+      fromFile: external_exports.string().optional().describe("Path to JSON payload file")
+    }),
+    run: async (context) => {
+      const studio = await getStudioRunContext(dependencies);
+      const appId = await studio.resolver.resolveAppId({
+        appId: context.options.appId,
+        appSlug: context.options.appSlug
+      });
+      const dataSourceId = await studio.resolver.resolveDataSourceId({
+        appId,
+        dataSourceId: context.options.dataSourceId,
+        dataSourceSlug: context.options.dataSourceSlug
+      });
+      const fieldId = await studio.resolver.resolveFieldId({
+        appId,
+        dataSourceId,
+        fieldId: context.options.fieldId,
+        fieldSlug: context.options.fieldSlug
+      });
+      const payload = normalizeBatchPayload(
+        await readStudioWriteInput({
+          data: context.options.data,
+          fromFile: context.options.fromFile
+        }),
+        "enumIds"
+      );
+      const response = await studio.apiClient.request({
+        method: "DELETE",
+        path: `/dev/apps/${appId}/data-sources/${dataSourceId}/fields/${fieldId}/enums`,
+        body: payload
+      });
+      return await wrapStudioPayload(studio.apiBaseUrl, dependencies, response.data);
+    }
+  });
+  return studioCli;
+}
+
 // src/services/apiClient.ts
 function normalizeResponseHeaders(headers) {
   const normalized = {};
@@ -40972,7 +42388,7 @@ var ApiClient = class {
 };
 
 // src/services/authSession.ts
-function isRecord(value) {
+function isRecord5(value) {
   return typeof value === "object" && value !== null;
 }
 function extractRecordValue(record2, keys) {
@@ -40983,7 +42399,7 @@ function extractRecordValue(record2, keys) {
   }
   return void 0;
 }
-function extractString(record2, keys) {
+function extractString2(record2, keys) {
   const value = extractRecordValue(record2, keys);
   return typeof value === "string" && value.length > 0 ? value : void 0;
 }
@@ -41271,15 +42687,15 @@ var AuthSessionService = class {
       fetchFn: this.params.fetchFn
     });
     const payload = response.data;
-    const dataCandidate = isRecord(payload) && isRecord(payload.data) ? payload.data : payload;
-    if (!isRecord(dataCandidate)) {
+    const dataCandidate = isRecord5(payload) && isRecord5(payload.data) ? payload.data : payload;
+    if (!isRecord5(dataCandidate)) {
       throw new AuthSessionError("Unable to parse /users/me response.");
     }
-    const tenantCandidate = isRecord(dataCandidate.tenant) ? dataCandidate.tenant : void 0;
-    const userId = extractString(dataCandidate, ["id", "user_id"]);
-    const email3 = extractString(dataCandidate, ["email"]);
-    const tenantId = tenantCandidate ? extractString(tenantCandidate, ["id"]) : extractString(dataCandidate, ["tenant_id", "tenantId"]);
-    const tenantName = tenantCandidate ? extractString(tenantCandidate, ["name"]) : extractString(dataCandidate, ["tenant_name", "tenantName"]);
+    const tenantCandidate = isRecord5(dataCandidate.tenant) ? dataCandidate.tenant : void 0;
+    const userId = extractString2(dataCandidate, ["id", "user_id"]);
+    const email3 = extractString2(dataCandidate, ["email"]);
+    const tenantId = tenantCandidate ? extractString2(tenantCandidate, ["id"]) : extractString2(dataCandidate, ["tenant_id", "tenantId"]);
+    const tenantName = tenantCandidate ? extractString2(tenantCandidate, ["name"]) : extractString2(dataCandidate, ["tenant_name", "tenantName"]);
     const tenantNo = tenantCandidate ? extractNumber(tenantCandidate, ["no", "tenant_no"]) : extractNumber(dataCandidate, ["tenant_no", "tenantNo"]);
     if (!userId || !email3 || !tenantId || !tenantName || !tenantNo) {
       throw new AuthSessionError("Incomplete identity data returned from /users/me.");
@@ -41301,17 +42717,17 @@ var AuthSessionService = class {
       fetchFn: this.params.fetchFn
     });
     const payload = response.data;
-    const listCandidate = Array.isArray(payload) ? payload : isRecord(payload) && Array.isArray(payload.data) ? payload.data : null;
+    const listCandidate = Array.isArray(payload) ? payload : isRecord5(payload) && Array.isArray(payload.data) ? payload.data : null;
     if (!listCandidate) {
       throw new AuthSessionError("Unable to parse tenant catalog response.");
     }
     const mapped = [];
     for (const item of listCandidate) {
-      if (!isRecord(item)) {
+      if (!isRecord5(item)) {
         continue;
       }
-      const tenantId = extractString(item, ["id", "tenant_id"]);
-      const tenantName = extractString(item, ["name"]);
+      const tenantId = extractString2(item, ["id", "tenant_id"]);
+      const tenantName = extractString2(item, ["name"]);
       const tenantNo = extractNumber(item, ["tenant_no", "tenantNo", "no"]);
       const logoValue = extractRecordValue(item, ["logo"]);
       const logo = typeof logoValue === "string" || logoValue === null ? logoValue : void 0;
@@ -41466,8 +42882,8 @@ var AuthSessionService = class {
 };
 
 // src/services/authStore.ts
-var import_promises2 = require("node:fs/promises");
-var import_node_path4 = require("node:path");
+var import_promises5 = require("node:fs/promises");
+var import_node_path6 = require("node:path");
 function createEmptyState() {
   return {
     version: 2,
@@ -41506,7 +42922,7 @@ var AuthStore = class {
   }
   async readState() {
     try {
-      const raw = await (0, import_promises2.readFile)(this.authFilePath, "utf8");
+      const raw = await (0, import_promises5.readFile)(this.authFilePath, "utf8");
       const parsed = JSON.parse(raw);
       const legacy = LegacyAuthSessionSchema.safeParse(parsed);
       if (legacy.success) {
@@ -41542,17 +42958,17 @@ var AuthStore = class {
       });
     }
     const normalized = normalizeState(validated.data);
-    const directory = (0, import_node_path4.dirname)(this.authFilePath);
-    await (0, import_promises2.mkdir)(directory, {
+    const directory = (0, import_node_path6.dirname)(this.authFilePath);
+    await (0, import_promises5.mkdir)(directory, {
       recursive: true,
       mode: 448
     });
-    await (0, import_promises2.writeFile)(this.authFilePath, `${JSON.stringify(normalized, null, 2)}
+    await (0, import_promises5.writeFile)(this.authFilePath, `${JSON.stringify(normalized, null, 2)}
 `, {
       encoding: "utf8",
       mode: 384
     });
-    await (0, import_promises2.chmod)(this.authFilePath, 384);
+    await (0, import_promises5.chmod)(this.authFilePath, 384);
   }
   async getActiveProfile(apiBaseUrl) {
     const normalizedApiBaseUrl = normalizeApiBaseUrl(apiBaseUrl);
@@ -41749,15 +43165,15 @@ var AuthStore = class {
     await this.writeState(state);
   }
   async clear() {
-    await (0, import_promises2.rm)(this.authFilePath, {
+    await (0, import_promises5.rm)(this.authFilePath, {
       force: true
     });
   }
 };
 
 // src/services/environmentConfig.ts
-var import_promises3 = require("node:fs/promises");
-var import_node_path5 = require("node:path");
+var import_promises6 = require("node:fs/promises");
+var import_node_path7 = require("node:path");
 var ENVIRONMENT_ID_ALIASES = {
   "local-development": "dev",
   prod: "live"
@@ -41843,7 +43259,7 @@ var EnvironmentConfigService = class {
   }
   async readState() {
     try {
-      const raw = await (0, import_promises3.readFile)(this.configFilePath, "utf8");
+      const raw = await (0, import_promises6.readFile)(this.configFilePath, "utf8");
       const parsed = JSON.parse(raw);
       const validated = EnvironmentConfigStateSchema.safeParse(parsed);
       if (!validated.success) {
@@ -41877,17 +43293,17 @@ var EnvironmentConfigService = class {
       });
     }
     const normalized = normalizeState2(validated.data);
-    const directory = (0, import_node_path5.dirname)(this.configFilePath);
-    await (0, import_promises3.mkdir)(directory, {
+    const directory = (0, import_node_path7.dirname)(this.configFilePath);
+    await (0, import_promises6.mkdir)(directory, {
       recursive: true,
       mode: 448
     });
-    await (0, import_promises3.writeFile)(this.configFilePath, `${JSON.stringify(normalized, null, 2)}
+    await (0, import_promises6.writeFile)(this.configFilePath, `${JSON.stringify(normalized, null, 2)}
 `, {
       encoding: "utf8",
       mode: 384
     });
-    await (0, import_promises3.chmod)(this.configFilePath, 384);
+    await (0, import_promises6.chmod)(this.configFilePath, 384);
   }
   async getActiveEnvironment() {
     const state = await this.#readStateWithDefaults();
@@ -41953,8 +43369,8 @@ var EnvironmentConfigService = class {
 };
 
 // src/services/tenantOpenApi.ts
-var import_promises4 = require("node:fs/promises");
-var import_node_path6 = require("node:path");
+var import_promises7 = require("node:fs/promises");
+var import_node_path8 = require("node:path");
 function resolveSourceUrl(tenantId, template) {
   return template.replace("{tenantId}", encodeURIComponent(tenantId));
 }
@@ -41962,6 +43378,14 @@ var TenantOpenApiService = class {
   constructor(params) {
     this.params = params;
   }
+  getTenantOpenApiFilePath(tenantId) {
+    const normalizedTenantId = tenantId.trim();
+    if (!normalizedTenantId) {
+      throw new AuthSessionError("Tenant ID is required to resolve OpenAPI spec path.");
+    }
+    const rootPath = this.params?.rootPath || TENANT_OPENAPI_ROOT_PATH;
+    return (0, import_node_path8.join)(rootPath, normalizedTenantId, "openapi.json");
+  }
   async downloadTenantOpenApi(tenantId) {
     const normalizedTenantId = tenantId.trim();
     if (!normalizedTenantId) {
@@ -41993,18 +43417,17 @@ var TenantOpenApiService = class {
         cause: error48
       });
     }
-    const rootPath = this.params?.rootPath || TENANT_OPENAPI_ROOT_PATH;
-    const filePath = (0, import_node_path6.join)(rootPath, normalizedTenantId, "openapi.json");
-    await (0, import_promises4.mkdir)((0, import_node_path6.dirname)(filePath), {
+    const filePath = this.getTenantOpenApiFilePath(normalizedTenantId);
+    await (0, import_promises7.mkdir)((0, import_node_path8.dirname)(filePath), {
       recursive: true,
       mode: 448
     });
-    await (0, import_promises4.writeFile)(filePath, `${JSON.stringify(parsedContent, null, 2)}
+    await (0, import_promises7.writeFile)(filePath, `${JSON.stringify(parsedContent, null, 2)}
 `, {
       encoding: "utf8",
       mode: 384
     });
-    await (0, import_promises4.chmod)(filePath, 384);
+    await (0, import_promises7.chmod)(filePath, 384);
     return {
       tenantId: normalizedTenantId,
       sourceUrl,
@@ -42021,8 +43444,14 @@ var ROOT_HELP_COMMANDS = [
   { command: "auth accounts list", description: "List saved user accounts" },
   { command: "auth tenants use --tenantId <id>", description: "Switch active tenant for selected user" },
   { command: "discover api", description: "Download active tenant OpenAPI spec" },
+  { command: "discover namespaces", description: "List namespaces from tenant OpenAPI spec" },
+  { command: "discover path <prefix>", description: "List endpoint paths by prefix" },
+  { command: "discover endpoint <path>", description: "Show endpoint object by exact path" },
+  { command: "discover entity <name>", description: "Show entity object by name" },
+  { command: "discover search <terms>", description: "Search in endpoint paths and entity names" },
   { command: "ds list <appSlug> <dataSourceSlug>", description: "List data source items" },
   { command: "apps list", description: "List apps" },
+  { command: "studio list-data-sources --appSlug <slug>", description: "List studio data sources" },
   { command: "curl <path>", description: "Send arbitrary API requests" }
 ];
 function createDocyrusCli(params) {
@@ -42090,6 +43519,11 @@ function createDocyrusCli(params) {
     environmentConfigService,
     authStore
   }));
+  cli2.command(createStudioCli({
+    createApiClient,
+    environmentConfigService,
+    authStore
+  }));
   cli2.command(createCurlCli({
     createApiClient,
     environmentConfigService,