@base44-preview/cli 0.0.34-pr.228.ff14dd8 → 0.0.34-pr.259.5b805fc

package/README.md

@@ -56,6 +56,11 @@ The CLI will guide you through project setup. For step-by-step tutorials, see th
 | [`connectors pull`](https://docs.base44.com/developers/references/cli/commands/connectors-pull) | Pull connectors from Base44 to local files |
 | [`connectors push`](https://docs.base44.com/developers/references/cli/commands/connectors-push) | Push local connectors to Base44 |
 | [`entities push`](https://docs.base44.com/developers/references/cli/commands/entities-push) | Push local entities to Base44 |
+| [`entities records list`](https://docs.base44.com/developers/references/cli/commands/entities-records) | List entity records |
+| [`entities records get`](https://docs.base44.com/developers/references/cli/commands/entities-records) | Get a single entity record by ID |
+| [`entities records create`](https://docs.base44.com/developers/references/cli/commands/entities-records) | Create a new entity record |
+| [`entities records update`](https://docs.base44.com/developers/references/cli/commands/entities-records) | Update an entity record |
+| [`entities records delete`](https://docs.base44.com/developers/references/cli/commands/entities-records) | Delete an entity record |
 | [`functions deploy`](https://docs.base44.com/developers/references/cli/commands/functions-deploy) | Deploy local functions to Base44 |
 | [`site deploy`](https://docs.base44.com/developers/references/cli/commands/site-deploy) | Deploy built site files to Base44 hosting |
 | [`site open`](https://docs.base44.com/developers/references/cli/commands/site-open) | Open the published site in your browser |

package/dist/cli/index.js

@@ -185389,16 +185389,18 @@ async function fetchAgents() {
 }
 // src/core/resources/agent/config.ts
 import { join as join3 } from "node:path";
-import { isDeepStrictEqual } from "node:util";
+function toFileSlug(name2) {
+  return name2.toLowerCase().replace(/[^a-z0-9_]/g, "_").replace(/_+/g, "_").replace(/^_|_$/g, "");
+}
 async function readAgentFile(agentPath) {
-  const raw2 = await readJsonFile(agentPath);
-  const result = AgentConfigSchema.safeParse(raw2);
+  const parsed = await readJsonFile(agentPath);
+  const result = AgentConfigSchema.safeParse(parsed);
   if (!result.success) {
     throw new SchemaValidationError("Invalid agent file", result.error, agentPath);
   }
-  return { data: result.data, raw: raw2 };
+  return result.data;
 }
-async function readAgentFiles(agentsDir) {
+async function readAllAgents(agentsDir) {
   if (!await pathExists(agentsDir)) {
     return [];
   }
@@ -185406,49 +185408,37 @@ async function readAgentFiles(agentsDir) {
     cwd: agentsDir,
     absolute: true
   });
-  return await Promise.all(files.map(async (filePath) => {
-    const { data, raw: raw2 } = await readAgentFile(filePath);
-    return { data, raw: raw2, filePath };
-  }));
-}
-async function readAllAgents(agentsDir) {
-  const entries = await readAgentFiles(agentsDir);
+  const agents = await Promise.all(files.map((filePath) => readAgentFile(filePath)));
   const names = new Set;
-  for (const { data } of entries) {
-    if (names.has(data.name)) {
-      throw new Error(`Duplicate agent name "${data.name}"`);
+  for (const agent of agents) {
+    if (names.has(agent.name)) {
+      throw new Error(`Duplicate agent name "${agent.name}"`);
     }
-    names.add(data.name);
+    names.add(agent.name);
   }
-  return entries.map((e2) => e2.data);
+  return agents;
 }
 async function writeAgents(agentsDir, remoteAgents) {
-  const entries = await readAgentFiles(agentsDir);
-  const nameToEntry = new Map;
-  for (const entry of entries) {
-    if (nameToEntry.has(entry.data.name)) {
-      throw new Error(`Duplicate agent name "${entry.data.name}"`);
-    }
-    nameToEntry.set(entry.data.name, entry);
-  }
+  const existingAgents = await readAllAgents(agentsDir);
   const newNames = new Set(remoteAgents.map((a) => a.name));
-  const deleted = [];
-  for (const [name2, entry] of nameToEntry) {
-    if (!newNames.has(name2)) {
-      await deleteFile(entry.filePath);
-      deleted.push(name2);
+  const toDelete = existingAgents.filter((a) => !newNames.has(a.name));
+  for (const agent of toDelete) {
+    const slug = toFileSlug(agent.name);
+    const files = await globby(`${slug}.${CONFIG_FILE_EXTENSION_GLOB}`, {
+      cwd: agentsDir,
+      absolute: true
+    });
+    for (const filePath of files) {
+      await deleteFile(filePath);
     }
   }
-  const written = [];
   for (const agent of remoteAgents) {
-    const existing = nameToEntry.get(agent.name);
-    if (existing && isDeepStrictEqual(existing.raw, agent)) {
-      continue;
-    }
-    const filePath = existing?.filePath ?? join3(agentsDir, `${agent.name}.${CONFIG_FILE_EXTENSION}`);
+    const slug = toFileSlug(agent.name);
+    const filePath = join3(agentsDir, `${slug}.${CONFIG_FILE_EXTENSION}`);
     await writeJsonFile(filePath, agent);
-    written.push(agent.name);
   }
+  const written = remoteAgents.map((a) => a.name);
+  const deleted = toDelete.map((a) => a.name);
   return { written, deleted };
 }
 // src/core/resources/agent/resource.ts
@@ -185665,7 +185655,7 @@ async function removeConnector(integrationType) {
 }
 // src/core/resources/connector/config.ts
 import { join as join4 } from "node:path";
-import { isDeepStrictEqual as isDeepStrictEqual2 } from "node:util";
+import { isDeepStrictEqual } from "node:util";
 async function readConnectorFile(connectorPath) {
   const parsed = await readJsonFile(connectorPath);
   const result = ConnectorResourceSchema.safeParse(parsed);
@@ -185726,7 +185716,7 @@ async function writeConnectors(connectorsDir, remoteConnectors) {
       type: connector.integrationType,
       scopes: connector.scopes
     };
-    if (existing && isDeepStrictEqual2(existing.data, localConnector)) {
+    if (existing && isDeepStrictEqual(existing.data, localConnector)) {
       continue;
     }
     const filePath = existing?.filePath ?? join4(connectorsDir, `${connector.integrationType}.${CONFIG_FILE_EXTENSION}`);
@@ -185959,6 +185949,118 @@ async function pushEntities(entities) {
   }
   return syncEntities(entities);
 }
+// src/core/resources/entity/records-schema.ts
+var EntityRecordSchema = exports_external.looseObject({
+  id: exports_external.string(),
+  created_date: exports_external.string(),
+  updated_date: exports_external.string(),
+  created_by: exports_external.string().optional()
+});
+var DeleteRecordResponseSchema = exports_external.object({
+  success: exports_external.boolean()
+});
+
+// src/core/resources/entity/records-api.ts
+async function listRecords(entityName, options = {}) {
+  const client = await getAppUserClient();
+  const searchParams = new URLSearchParams;
+  if (options.filter) {
+    searchParams.set("q", options.filter);
+  }
+  if (options.sort) {
+    searchParams.set("sort", options.sort);
+  }
+  if (options.limit !== undefined) {
+    searchParams.set("limit", String(options.limit));
+  }
+  if (options.skip !== undefined) {
+    searchParams.set("skip", String(options.skip));
+  }
+  if (options.fields) {
+    searchParams.set("fields", options.fields);
+  }
+  let response;
+  try {
+    response = await client.get(`entities/${entityName}`, {
+      searchParams
+    });
+  } catch (error48) {
+    throw await ApiError.fromHttpError(error48, "listing records");
+  }
+  const json2 = await response.json();
+  const records = Array.isArray(json2) ? json2 : [];
+  return records.map((record2) => {
+    const result = EntityRecordSchema.safeParse(record2);
+    if (!result.success) {
+      throw new SchemaValidationError("Invalid record in response", result.error);
+    }
+    return result.data;
+  });
+}
+async function getRecord(entityName, recordId) {
+  const client = await getAppUserClient();
+  let response;
+  try {
+    response = await client.get(`entities/${entityName}/${recordId}`);
+  } catch (error48) {
+    throw await ApiError.fromHttpError(error48, "getting record");
+  }
+  const json2 = await response.json();
+  const result = EntityRecordSchema.safeParse(json2);
+  if (!result.success) {
+    throw new SchemaValidationError("Invalid record response", result.error);
+  }
+  return result.data;
+}
+async function createRecord(entityName, data) {
+  const client = await getAppUserClient();
+  let response;
+  try {
+    response = await client.post(`entities/${entityName}`, {
+      json: data
+    });
+  } catch (error48) {
+    throw await ApiError.fromHttpError(error48, "creating record");
+  }
+  const json2 = await response.json();
+  const result = EntityRecordSchema.safeParse(json2);
+  if (!result.success) {
+    throw new SchemaValidationError("Invalid record in create response", result.error);
+  }
+  return result.data;
+}
+async function updateRecord(entityName, recordId, data) {
+  const client = await getAppUserClient();
+  let response;
+  try {
+    response = await client.put(`entities/${entityName}/${recordId}`, {
+      json: data
+    });
+  } catch (error48) {
+    throw await ApiError.fromHttpError(error48, "updating record");
+  }
+  const json2 = await response.json();
+  const result = EntityRecordSchema.safeParse(json2);
+  if (!result.success) {
+    throw new SchemaValidationError("Invalid record in update response", result.error);
+  }
+  return result.data;
+}
+async function deleteRecord(entityName, recordId) {
+  const client = await getAppUserClient();
+  let response;
+  try {
+    response = await client.delete(`entities/${entityName}/${recordId}`);
+  } catch (error48) {
+    throw await ApiError.fromHttpError(error48, "deleting record");
+  }
+  const json2 = await response.json();
+  const result = DeleteRecordResponseSchema.safeParse(json2);
+  if (!result.success) {
+    throw new SchemaValidationError("Invalid delete response", result.error);
+  }
+  return result.data;
+}
 // src/core/resources/entity/resource.ts
 var entityResource = {
   readAll: readAllEntities,
@@ -186547,6 +186649,21 @@ function getAppClient() {
     prefixUrl: new URL(`/api/apps/${id}/`, getBase44ApiUrl()).href
   });
 }
+async function getAppUserClient() {
+  const appClient = getAppClient();
+  const response = await appClient.get("auth/token");
+  const { token } = await response.json();
+  const { id } = getAppConfig();
+  return distribution_default.create({
+    prefixUrl: new URL(`/api/apps/${id}/`, getBase44ApiUrl()).href,
+    headers: {
+      "User-Agent": "Base44 CLI",
+      Authorization: `Bearer ${token}`,
+      "X-Bypass-RLS": "true",
+      "X-Bypass-Entities-Filter-Limit": "true"
+    }
+  });
+}
 // src/core/clients/oauth-client.ts
 var oauthClient = distribution_default.create({
   prefixUrl: getBase44ApiUrl(),
@@ -194140,11 +194257,14 @@ async function pullAgentsAction() {
     successMessage: "Agents fetched successfully",
     errorMessage: "Failed to fetch agents"
   });
-  const { written, deleted } = await runTask("Syncing agent files", async () => {
+  if (remoteAgents.items.length === 0) {
+    return { outroMessage: "No agents found on Base44" };
+  }
+  const { written, deleted } = await runTask("Writing agent files", async () => {
     return await writeAgents(agentsDir, remoteAgents.items);
   }, {
-    successMessage: "Agent files synced successfully",
-    errorMessage: "Failed to sync agent files"
+    successMessage: "Agent files written successfully",
+    errorMessage: "Failed to write agent files"
   });
   if (written.length > 0) {
     R2.success(`Written: ${written.join(", ")}`);
@@ -194152,9 +194272,6 @@ async function pullAgentsAction() {
   if (deleted.length > 0) {
     R2.warn(`Deleted: ${deleted.join(", ")}`);
   }
-  if (written.length === 0 && deleted.length === 0) {
-    R2.info("All agents are already up to date");
-  }
   return {
     outroMessage: `Pulled ${remoteAgents.total} agents to ${agentsDir}`
   };
@@ -195074,9 +195191,150 @@ async function pushEntitiesAction() {
   return { outroMessage: "Entities pushed to Base44" };
 }
 function getEntitiesPushCommand(context) {
-  return new Command("entities").description("Manage project entities").addCommand(new Command("push").description("Push local entities to Base44").action(async () => {
+  return new Command("push").description("Push local entity schemas to Base44").action(async () => {
     await runCommand(pushEntitiesAction, { requireAuth: true }, context);
-  }));
+  });
+}
+
+// src/cli/commands/entities/records/parseRecordData.ts
+var import_json52 = __toESM(require_lib(), 1);
+async function parseRecordData(options, exampleHint) {
+  if (options.data && options.file) {
+    throw new InvalidInputError("Cannot use both --data and --file. Choose one.", {
+      hints: [
+        {
+          message: `Pass --data for inline JSON or --file for a JSON file path, not both.`
+        }
+      ]
+    });
+  }
+  if (options.data) {
+    try {
+      return import_json52.default.parse(options.data);
+    } catch {
+      throw new InvalidInputError("Invalid JSON in --data flag. Provide valid JSON.", exampleHint ? { hints: [{ message: `Example: --data '${exampleHint}'` }] } : undefined);
+    }
+  }
+  if (options.file) {
+    return readJsonFile(options.file);
+  }
+  throw new InvalidInputError("Provide record data with --data or --file flag", exampleHint ? {
+    hints: [
+      {
+        message: `Example: --data '${exampleHint}' or --file record.json`
+      }
+    ]
+  } : undefined);
+}
+
+// src/cli/commands/entities/records/create.ts
+async function createRecordAction(entityName, options) {
+  const data = await parseRecordData(options, '{"name": "John", "email": "john@example.com"}');
+  const record2 = await runTask(`Creating ${entityName} record...`, async () => {
+    return await createRecord(entityName, data);
+  }, {
+    successMessage: `Created ${entityName} record`,
+    errorMessage: `Failed to create ${entityName} record`
+  });
+  R2.info(JSON.stringify(record2, null, 2));
+  return { outroMessage: `Record created with ID: ${record2.id}` };
+}
+function getRecordsCreateCommand(context) {
+  return new Command("create").description("Create a new entity record").argument("<entity-name>", "Name of the entity (e.g. Users, Products)").option("-d, --data <json>", "JSON object with record data").option("--file <path>", "Read record data from a JSON/JSONC file").action(async (entityName, options) => {
+    await runCommand(() => createRecordAction(entityName, options), { requireAuth: true }, context);
+  });
+}
+
+// src/cli/commands/entities/records/delete.ts
+async function deleteRecordAction(entityName, recordId, options) {
+  if (!options.yes) {
+    const confirmed = await Re({
+      message: `Delete ${entityName} record ${recordId}?`
+    });
+    if (confirmed !== true) {
+      throw new CLIExitError(0);
+    }
+  }
+  await runTask(`Deleting ${entityName} record...`, async () => {
+    return await deleteRecord(entityName, recordId);
+  }, {
+    successMessage: `Deleted ${entityName} record`,
+    errorMessage: `Failed to delete ${entityName} record`
+  });
+  return { outroMessage: `Record ${recordId} deleted` };
+}
+function getRecordsDeleteCommand(context) {
+  return new Command("delete").description("Delete an entity record").argument("<entity-name>", "Name of the entity (e.g. Users, Products)").argument("<record-id>", "ID of the record to delete").option("-y, --yes", "Skip confirmation prompt").action(async (entityName, recordId, options) => {
+    await runCommand(() => deleteRecordAction(entityName, recordId, options), { requireAuth: true }, context);
+  });
+}
+
+// src/cli/commands/entities/records/get.ts
+async function getRecordAction(entityName, recordId) {
+  const record2 = await runTask(`Fetching ${entityName} record...`, async () => {
+    return await getRecord(entityName, recordId);
+  }, {
+    successMessage: `Fetched ${entityName} record`,
+    errorMessage: `Failed to fetch ${entityName} record`
+  });
+  R2.info(JSON.stringify(record2, null, 2));
+  return {};
+}
+function getRecordsGetCommand(context) {
+  return new Command("get").description("Get a single entity record by ID").argument("<entity-name>", "Name of the entity (e.g. Users, Products)").argument("<record-id>", "ID of the record").action(async (entityName, recordId) => {
+    await runCommand(() => getRecordAction(entityName, recordId), { requireAuth: true }, context);
+  });
+}
+
+// src/cli/commands/entities/records/list.ts
+async function listRecordsAction(entityName, options) {
+  const records = await runTask(`Fetching ${entityName} records...`, async () => {
+    return await listRecords(entityName, {
+      filter: options.filter,
+      sort: options.sort,
+      limit: options.limit ? Number(options.limit) : 50,
+      skip: options.skip ? Number(options.skip) : undefined,
+      fields: options.fields
+    });
+  }, {
+    successMessage: `Fetched ${entityName} records`,
+    errorMessage: `Failed to fetch ${entityName} records`
+  });
+  R2.info(JSON.stringify(records, null, 2));
+  return { outroMessage: `Found ${records.length} ${entityName} record(s)` };
+}
+function getRecordsListCommand(context) {
+  return new Command("list").description("List entity records").argument("<entity-name>", "Name of the entity (e.g. Users, Products)").option("-f, --filter <json>", `JSON filter object (e.g. '{"status":"active"}' or '{"age":{"$gt":18}}')`).option("-s, --sort <field>", "Sort field name, prefix with - for descending (e.g. -created_date)").option("-l, --limit <n>", "Max number of records to return", "50").option("--skip <n>", "Number of records to skip (for pagination)").option("--fields <fields>", "Comma-separated list of fields to return (e.g. id,name,email)").action(async (entityName, options) => {
+    await runCommand(() => listRecordsAction(entityName, options), { requireAuth: true }, context);
+  });
+}
+
+// src/cli/commands/entities/records/update.ts
+async function updateRecordAction(entityName, recordId, options) {
+  const data = await parseRecordData(options, '{"status": "active"}');
+  const record2 = await runTask(`Updating ${entityName} record...`, async () => {
+    return await updateRecord(entityName, recordId, data);
+  }, {
+    successMessage: `Updated ${entityName} record`,
+    errorMessage: `Failed to update ${entityName} record`
+  });
+  R2.info(JSON.stringify(record2, null, 2));
+  return { outroMessage: `Record ${recordId} updated` };
+}
+function getRecordsUpdateCommand(context) {
+  return new Command("update").description("Update an entity record").argument("<entity-name>", "Name of the entity (e.g. Users, Products)").argument("<record-id>", "ID of the record to update").option("-d, --data <json>", "JSON object with fields to update").option("--file <path>", "Read update data from a JSON/JSONC file").action(async (entityName, recordId, options) => {
+    await runCommand(() => updateRecordAction(entityName, recordId, options), { requireAuth: true }, context);
+  });
+}
+
+// src/cli/commands/entities/records/index.ts
+function getRecordsCommand(context) {
+  return new Command("records").description("CRUD operations on entity records").addCommand(getRecordsListCommand(context)).addCommand(getRecordsGetCommand(context)).addCommand(getRecordsCreateCommand(context)).addCommand(getRecordsUpdateCommand(context)).addCommand(getRecordsDeleteCommand(context));
+}
+
+// src/cli/commands/entities/index.ts
+function getEntitiesCommand(context) {
+  return new Command("entities").description("Manage project entities").addCommand(getEntitiesPushCommand(context)).addCommand(getRecordsCommand(context));
 }
 
 // src/cli/commands/functions/deploy.ts
@@ -196343,7 +196601,7 @@ function createProgram(context) {
   program2.addCommand(getDeployCommand(context));
   program2.addCommand(getLinkCommand(context));
   program2.addCommand(getEjectCommand(context));
-  program2.addCommand(getEntitiesPushCommand(context));
+  program2.addCommand(getEntitiesCommand(context));
   program2.addCommand(getAgentsCommand(context));
   program2.addCommand(getConnectorsCommand(context));
   program2.addCommand(getFunctionsDeployCommand(context));
@@ -200615,4 +200873,4 @@ export {
   CLIExitError
 };
 
-//# debugId=199B0E01CD0F366764756E2164756E21
+//# debugId=50E9171D5E0E5F6864756E2164756E21