@base44-preview/cli 0.0.44-pr.417.2c58950 → 0.0.45-pr.357.f38fab3

package/dist/cli/index.js

@@ -16459,7 +16459,7 @@ var require_lodash = __commonJS((exports, module) => {
         }
         return mapped.length && mapped[0] === arrays[0] ? baseIntersection(mapped, undefined2, comparator) : [];
       });
-      function join10(array2, separator) {
+      function join11(array2, separator) {
         return array2 == null ? "" : nativeJoin.call(array2, separator);
       }
       function last(array2) {
@@ -16481,7 +16481,7 @@ var require_lodash = __commonJS((exports, module) => {
       function nth(array2, n2) {
         return array2 && array2.length ? baseNth(array2, toInteger(n2)) : undefined2;
       }
-      var pull2 = baseRest(pullAll);
+      var pull3 = baseRest(pullAll);
       function pullAll(array2, values2) {
         return array2 && array2.length && values2 && values2.length ? basePullAll(array2, values2) : array2;
       }
@@ -18246,7 +18246,7 @@ __p += '`;
       lodash.pickBy = pickBy;
       lodash.property = property;
       lodash.propertyOf = propertyOf;
-      lodash.pull = pull2;
+      lodash.pull = pull3;
       lodash.pullAll = pullAll;
       lodash.pullAllBy = pullAllBy;
       lodash.pullAllWith = pullAllWith;
@@ -18391,7 +18391,7 @@ __p += '`;
       lodash.isUndefined = isUndefined;
       lodash.isWeakMap = isWeakMap;
       lodash.isWeakSet = isWeakSet;
-      lodash.join = join10;
+      lodash.join = join11;
       lodash.kebabCase = kebabCase;
       lodash.last = last;
       lodash.lastIndexOf = lastIndexOf;
@@ -27503,7 +27503,7 @@ function cleanDoc(doc2) {
   return mapDoc(doc2, (currentDoc) => cleanDocFn(currentDoc));
 }
 function replaceEndOfLine(doc2, replacement = literalline) {
-  return mapDoc(doc2, (currentDoc) => typeof currentDoc === "string" ? join13(replacement, currentDoc.split(`
+  return mapDoc(doc2, (currentDoc) => typeof currentDoc === "string" ? join15(replacement, currentDoc.split(`
 `)) : currentDoc);
 }
 function canBreakFn(doc2) {
@@ -27583,7 +27583,7 @@ function indentIfBreak(contents, options) {
     negate: options.negate
   };
 }
-function join13(separator, docs) {
+function join15(separator, docs) {
   assertDoc(separator);
   assertDocArray(docs);
   const parts = [];
@@ -28294,7 +28294,7 @@ var init_doc = __esm(() => {
   MODE_FLAT = Symbol("MODE_FLAT");
   DOC_FILL_PRINTED_LENGTH = Symbol("DOC_FILL_PRINTED_LENGTH");
   builders = {
-    join: join13,
+    join: join15,
     line,
     softline,
     hardline,
@@ -133208,7 +133208,7 @@ Expected it to be ${EXPECTED_TYPE_VALUES}.`;
       return mapDoc2(doc2, (currentDoc) => cleanDocFn2(currentDoc));
     }
     function replaceEndOfLine2(doc2, replacement = literalline2) {
-      return mapDoc2(doc2, (currentDoc) => typeof currentDoc === "string" ? join15(replacement, currentDoc.split(`
+      return mapDoc2(doc2, (currentDoc) => typeof currentDoc === "string" ? join17(replacement, currentDoc.split(`
 `)) : currentDoc);
     }
     function canBreakFn2(doc2) {
@@ -133294,7 +133294,7 @@ Expected it to be ${EXPECTED_TYPE_VALUES}.`;
         negate: options8.negate
       };
     }
-    function join15(separator, docs) {
+    function join17(separator, docs) {
       assertDoc2(separator);
       assertDocArray2(docs);
       const parts = [];
@@ -133959,7 +133959,7 @@ Expected it to be ${EXPECTED_TYPE_VALUES}.`;
       }
     }
     var builders2 = {
-      join: join15,
+      join: join17,
       line: line3,
       softline: softline2,
       hardline: hardline4,
@@ -160399,10 +160399,10 @@ var require_view = __commonJS((exports, module) => {
   var debug = require_src4()("express:view");
   var path18 = __require("node:path");
   var fs28 = __require("node:fs");
-  var dirname11 = path18.dirname;
+  var dirname12 = path18.dirname;
   var basename4 = path18.basename;
   var extname2 = path18.extname;
-  var join16 = path18.join;
+  var join18 = path18.join;
   var resolve6 = path18.resolve;
   module.exports = View;
   function View(name2, options8) {
@@ -160438,7 +160438,7 @@ var require_view = __commonJS((exports, module) => {
     for (var i5 = 0;i5 < roots.length && !path19; i5++) {
       var root2 = roots[i5];
       var loc = resolve6(root2, name2);
-      var dir = dirname11(loc);
+      var dir = dirname12(loc);
       var file2 = basename4(loc);
       path19 = this.resolve(dir, file2);
     }
@@ -160464,12 +160464,12 @@ var require_view = __commonJS((exports, module) => {
   };
   View.prototype.resolve = function resolve7(dir, file2) {
     var ext = this.ext;
-    var path19 = join16(dir, file2);
+    var path19 = join18(dir, file2);
     var stat2 = tryStat(path19);
     if (stat2 && stat2.isFile()) {
       return path19;
     }
-    path19 = join16(dir, basename4(file2, ext), "index" + ext);
+    path19 = join18(dir, basename4(file2, ext), "index" + ext);
     stat2 = tryStat(path19);
     if (stat2 && stat2.isFile()) {
       return path19;
@@ -164164,7 +164164,7 @@ var require_send = __commonJS((exports, module) => {
   var Stream2 = __require("stream");
   var util2 = __require("util");
   var extname2 = path18.extname;
-  var join16 = path18.join;
+  var join18 = path18.join;
   var normalize = path18.normalize;
   var resolve6 = path18.resolve;
   var sep = path18.sep;
@@ -164336,7 +164336,7 @@ var require_send = __commonJS((exports, module) => {
         return res;
       }
       parts = path19.split(sep);
-      path19 = normalize(join16(root2, path19));
+      path19 = normalize(join18(root2, path19));
     } else {
       if (UP_PATH_REGEXP.test(path19)) {
         debug('malicious path "%s"', path19);
@@ -164476,7 +164476,7 @@ var require_send = __commonJS((exports, module) => {
           return self2.onStatError(err);
         return self2.error(404);
       }
-      var p4 = join16(path19, self2._index[i5]);
+      var p4 = join18(path19, self2._index[i5]);
       debug('stat "%s"', p4);
       fs28.stat(p4, function(err2, stat2) {
         if (err2)
@@ -168535,8 +168535,8 @@ var require_executor = __commonJS((exports, module) => {
     }
     resetBuffer() {
       this.buffer = new Waterfall;
-      this.buffer.chain(new Promise((resolve6) => {
-        this._triggerBuffer = resolve6;
+      this.buffer.chain(new Promise((resolve7) => {
+        this._triggerBuffer = resolve7;
       }));
       if (this.ready)
         this._triggerBuffer();
@@ -169556,7 +169556,7 @@ var require_storage = __commonJS((exports, module) => {
       throw e8;
     }
   };
-  var writeFileLinesAsync = (filename, lines, mode = DEFAULT_FILE_MODE) => new Promise((resolve6, reject) => {
+  var writeFileLinesAsync = (filename, lines, mode = DEFAULT_FILE_MODE) => new Promise((resolve7, reject) => {
     try {
       const stream = writeFileStream(filename, { mode });
       const readable2 = Readable6.from(lines);
@@ -169573,7 +169573,7 @@ var require_storage = __commonJS((exports, module) => {
           if (err)
             reject(err);
           else
-            resolve6();
+            resolve7();
         });
       });
       readable2.on("error", (err) => {
@@ -169744,7 +169744,7 @@ var require_persistence = __commonJS((exports, module) => {
       return { data: tdata, indexes };
     }
     treatRawStreamAsync(rawStream) {
-      return new Promise((resolve6, reject) => {
+      return new Promise((resolve7, reject) => {
         const dataById = {};
         const indexes = {};
         let corruptItems = 0;
@@ -169787,7 +169787,7 @@ var require_persistence = __commonJS((exports, module) => {
             }
           }
           const data = Object.values(dataById);
-          resolve6({ data, indexes });
+          resolve7({ data, indexes });
         });
         lineStream.on("error", function(err) {
           reject(err, null);
@@ -195398,13 +195398,13 @@ var require_broadcast_operator = __commonJS((exports) => {
       return true;
     }
     emitWithAck(ev2, ...args) {
-      return new Promise((resolve6, reject) => {
+      return new Promise((resolve7, reject) => {
         args.push((err, responses) => {
           if (err) {
             err.responses = responses;
             return reject(err);
           } else {
-            return resolve6(responses);
+            return resolve7(responses);
           }
         });
         this.emit(ev2, ...args);
@@ -195592,12 +195592,12 @@ var require_socket2 = __commonJS((exports) => {
     }
     emitWithAck(ev2, ...args) {
       const withErr = this.flags.timeout !== undefined;
-      return new Promise((resolve6, reject) => {
+      return new Promise((resolve7, reject) => {
         args.push((arg1, arg2) => {
           if (withErr) {
-            return arg1 ? reject(arg1) : resolve6(arg2);
+            return arg1 ? reject(arg1) : resolve7(arg2);
           } else {
-            return resolve6(arg1);
+            return resolve7(arg1);
           }
         });
         this.emit(ev2, ...args);
@@ -196052,13 +196052,13 @@ var require_namespace = __commonJS((exports) => {
       return true;
     }
     serverSideEmitWithAck(ev2, ...args) {
-      return new Promise((resolve6, reject) => {
+      return new Promise((resolve7, reject) => {
         args.push((err, responses) => {
           if (err) {
             err.responses = responses;
             return reject(err);
           } else {
-            return resolve6(responses);
+            return resolve7(responses);
           }
         });
         this.serverSideEmit(ev2, ...args);
@@ -196742,7 +196742,7 @@ var require_cluster_adapter = __commonJS((exports) => {
         return localSockets;
       }
       const requestId = randomId();
-      return new Promise((resolve6, reject) => {
+      return new Promise((resolve7, reject) => {
         const timeout3 = setTimeout(() => {
           const storedRequest2 = this.requests.get(requestId);
           if (storedRequest2) {
@@ -196752,7 +196752,7 @@ var require_cluster_adapter = __commonJS((exports) => {
         }, opts.flags.timeout || DEFAULT_TIMEOUT);
         const storedRequest = {
           type: MessageType.FETCH_SOCKETS,
-          resolve: resolve6,
+          resolve: resolve7,
           timeout: timeout3,
           current: 0,
           expected: expectedResponseCount,
@@ -196962,7 +196962,7 @@ var require_cluster_adapter = __commonJS((exports) => {
         return localSockets;
       }
       const requestId = randomId();
-      return new Promise((resolve6, reject) => {
+      return new Promise((resolve7, reject) => {
         const timeout3 = setTimeout(() => {
           const storedRequest2 = this.customRequests.get(requestId);
           if (storedRequest2) {
@@ -196972,7 +196972,7 @@ var require_cluster_adapter = __commonJS((exports) => {
         }, opts.flags.timeout || DEFAULT_TIMEOUT);
         const storedRequest = {
           type: MessageType.FETCH_SOCKETS,
-          resolve: resolve6,
+          resolve: resolve7,
           timeout: timeout3,
           missingUids: new Set([...this.nodesMap.keys()]),
           responses: localSockets
@@ -197701,13 +197701,13 @@ var require_dist4 = __commonJS((exports, module) => {
       this.engine.close();
       (0, uws_1.restoreAdapter)();
       if (this.httpServer) {
-        return new Promise((resolve6) => {
+        return new Promise((resolve7) => {
           this.httpServer.close((err) => {
             fn9 && fn9(err);
             if (err) {
               debug("server was not running");
             }
-            resolve6();
+            resolve7();
           });
         });
       } else {
@@ -211071,7 +211071,7 @@ var require_buffer_list = __commonJS((exports, module) => {
       }
     }, {
       key: "join",
-      value: function join16(s5) {
+      value: function join18(s5) {
         if (this.length === 0)
           return "";
         var p4 = this.head;
@@ -212426,14 +212426,14 @@ var require_async_iterator = __commonJS((exports, module) => {
     };
   }
   function readAndResolve(iter) {
-    var resolve6 = iter[kLastResolve];
-    if (resolve6 !== null) {
+    var resolve7 = iter[kLastResolve];
+    if (resolve7 !== null) {
       var data = iter[kStream].read();
       if (data !== null) {
         iter[kLastPromise] = null;
         iter[kLastResolve] = null;
         iter[kLastReject] = null;
-        resolve6(createIterResult(data, false));
+        resolve7(createIterResult(data, false));
       }
     }
   }
@@ -212441,13 +212441,13 @@ var require_async_iterator = __commonJS((exports, module) => {
     process.nextTick(readAndResolve, iter);
   }
   function wrapForNext(lastPromise, iter) {
-    return function(resolve6, reject) {
+    return function(resolve7, reject) {
       lastPromise.then(function() {
         if (iter[kEnded]) {
-          resolve6(createIterResult(undefined, true));
+          resolve7(createIterResult(undefined, true));
           return;
         }
-        iter[kHandlePromise](resolve6, reject);
+        iter[kHandlePromise](resolve7, reject);
       }, reject);
     };
   }
@@ -212466,12 +212466,12 @@ var require_async_iterator = __commonJS((exports, module) => {
         return Promise.resolve(createIterResult(undefined, true));
       }
       if (this[kStream].destroyed) {
-        return new Promise(function(resolve6, reject) {
+        return new Promise(function(resolve7, reject) {
           process.nextTick(function() {
             if (_this[kError]) {
               reject(_this[kError]);
             } else {
-              resolve6(createIterResult(undefined, true));
+              resolve7(createIterResult(undefined, true));
             }
           });
         });
@@ -212494,13 +212494,13 @@ var require_async_iterator = __commonJS((exports, module) => {
     return this;
   }), _defineProperty(_Object$setPrototypeO, "return", function _return() {
     var _this2 = this;
-    return new Promise(function(resolve6, reject) {
+    return new Promise(function(resolve7, reject) {
       _this2[kStream].destroy(null, function(err) {
         if (err) {
           reject(err);
           return;
         }
-        resolve6(createIterResult(undefined, true));
+        resolve7(createIterResult(undefined, true));
       });
     });
   }), _Object$setPrototypeO), AsyncIteratorPrototype);
@@ -212522,15 +212522,15 @@ var require_async_iterator = __commonJS((exports, module) => {
       value: stream._readableState.endEmitted,
       writable: true
     }), _defineProperty(_Object$create, kHandlePromise, {
-      value: function value(resolve6, reject) {
+      value: function value(resolve7, reject) {
         var data = iterator[kStream].read();
         if (data) {
           iterator[kLastPromise] = null;
           iterator[kLastResolve] = null;
           iterator[kLastReject] = null;
-          resolve6(createIterResult(data, false));
+          resolve7(createIterResult(data, false));
         } else {
-          iterator[kLastResolve] = resolve6;
+          iterator[kLastResolve] = resolve7;
           iterator[kLastReject] = reject;
         }
       },
@@ -212549,12 +212549,12 @@ var require_async_iterator = __commonJS((exports, module) => {
         iterator[kError] = err;
         return;
       }
-      var resolve6 = iterator[kLastResolve];
-      if (resolve6 !== null) {
+      var resolve7 = iterator[kLastResolve];
+      if (resolve7 !== null) {
         iterator[kLastPromise] = null;
         iterator[kLastResolve] = null;
         iterator[kLastReject] = null;
-        resolve6(createIterResult(undefined, true));
+        resolve7(createIterResult(undefined, true));
       }
       iterator[kEnded] = true;
     });
@@ -212566,7 +212566,7 @@ var require_async_iterator = __commonJS((exports, module) => {
 
 // ../../node_modules/readable-stream/lib/internal/streams/from.js
 var require_from = __commonJS((exports, module) => {
-  function asyncGeneratorStep(gen, resolve6, reject, _next, _throw, key2, arg) {
+  function asyncGeneratorStep(gen, resolve7, reject, _next, _throw, key2, arg) {
     try {
       var info = gen[key2](arg);
       var value = info.value;
@@ -212575,7 +212575,7 @@ var require_from = __commonJS((exports, module) => {
       return;
     }
     if (info.done) {
-      resolve6(value);
+      resolve7(value);
     } else {
       Promise.resolve(value).then(_next, _throw);
     }
@@ -212583,13 +212583,13 @@ var require_from = __commonJS((exports, module) => {
   function _asyncToGenerator(fn9) {
     return function() {
       var self2 = this, args = arguments;
-      return new Promise(function(resolve6, reject) {
+      return new Promise(function(resolve7, reject) {
         var gen = fn9.apply(self2, args);
         function _next(value) {
-          asyncGeneratorStep(gen, resolve6, reject, _next, _throw, "next", value);
+          asyncGeneratorStep(gen, resolve7, reject, _next, _throw, "next", value);
         }
         function _throw(err) {
-          asyncGeneratorStep(gen, resolve6, reject, _next, _throw, "throw", err);
+          asyncGeneratorStep(gen, resolve7, reject, _next, _throw, "throw", err);
         }
         _next(undefined);
       });
@@ -214717,7 +214717,7 @@ var require_dist5 = __commonJS((exports, module) => {
   });
   module.exports = __toCommonJS(src_exports);
   var import_promises22 = __require("node:fs/promises");
-  var import_node_fs22 = __require("node:fs");
+  var import_node_fs23 = __require("node:fs");
   var DEVIN_LOCAL_PATH = "/opt/.devin";
   var CURSOR2 = "cursor";
   var CURSOR_CLI = "cursor-cli";
@@ -214774,7 +214774,7 @@ var require_dist5 = __commonJS((exports, module) => {
       return { isAgent: true, agent: { name: REPLIT } };
     }
     try {
-      await (0, import_promises22.access)(DEVIN_LOCAL_PATH, import_node_fs22.constants.F_OK);
+      await (0, import_promises22.access)(DEVIN_LOCAL_PATH, import_node_fs23.constants.F_OK);
       return { isAgent: true, agent: { name: DEVIN } };
     } catch (error48) {}
     return { isAgent: false, agent: undefined };
@@ -214782,8 +214782,8 @@ var require_dist5 = __commonJS((exports, module) => {
 });
 
 // src/cli/index.ts
-import { dirname as dirname15, join as join19 } from "node:path";
-import { fileURLToPath as fileURLToPath6 } from "node:url";
+import { dirname as dirname17, join as join22 } from "node:path";
+import { fileURLToPath as fileURLToPath7 } from "node:url";
 
 // ../../node_modules/commander/esm.mjs
 var import__ = __toESM(require_commander(), 1);
@@ -214802,7 +214802,7 @@ var {
 } = import__.default;
 
 // src/cli/commands/agents/pull.ts
-import { dirname as dirname7, join as join10 } from "node:path";
+import { dirname as dirname7, join as join11 } from "node:path";
 
 // ../../node_modules/@clack/core/dist/index.mjs
 var import_picocolors = __toESM(require_picocolors(), 1);
@@ -237317,7 +237317,7 @@ var generateGlobTasks = normalizeArguments(generateTasks);
 var generateGlobTasksSync = normalizeArgumentsSync(generateTasksSync);
 
 // src/core/project/config.ts
-import { dirname as dirname5, join as join6 } from "node:path";
+import { dirname as dirname5, join as join7 } from "node:path";
 
 // src/core/resources/agent/schema.ts
 var EntityOperationSchema = exports_external.enum(["create", "update", "delete", "read"]);
@@ -238100,7 +238100,7 @@ var FieldRLSSchema = exports_external.looseObject({
   delete: RLSRuleSchema.optional()
 });
 var PropertyDefinitionSchema = exports_external.looseObject({
-  type: exports_external.string().optional(),
+  type: exports_external.string(),
   title: exports_external.string().optional(),
   description: exports_external.string().optional(),
   minLength: exports_external.number().int().min(0).optional(),
@@ -238249,11 +238249,24 @@ var BackendFunctionSchema = FunctionConfigSchema.extend({
   entryPath: exports_external.string().min(1, "Entry path cannot be empty"),
   filePaths: exports_external.array(exports_external.string()).min(1, "Function must have at least one file")
 });
-var DeployFunctionsResponseSchema = exports_external.object({
-  deployed: exports_external.array(exports_external.string()),
-  deleted: exports_external.array(exports_external.string()),
-  skipped: exports_external.array(exports_external.string()).optional().nullable(),
-  errors: exports_external.array(exports_external.object({ name: exports_external.string(), message: exports_external.string() })).nullable()
+var DeploySingleFunctionResponseSchema = exports_external.object({
+  status: exports_external.enum(["deployed", "unchanged"])
+});
+var FunctionInfoSchema = exports_external.object({
+  name: exports_external.string(),
+  deployment_id: exports_external.string(),
+  entry: exports_external.string(),
+  files: exports_external.array(FunctionFileSchema),
+  automations: exports_external.array(AutomationSchema)
+}).transform((data) => ({
+  name: data.name,
+  deploymentId: data.deployment_id,
+  entry: data.entry,
+  files: data.files,
+  automations: data.automations
+}));
+var ListFunctionsResponseSchema = exports_external.object({
+  functions: exports_external.array(FunctionInfoSchema)
 });
 var LogLevelSchema = exports_external.enum(["info", "warning", "error", "debug"]);
 var FunctionLogEntrySchema = exports_external.object({
@@ -238264,29 +238277,39 @@ var FunctionLogEntrySchema = exports_external.object({
 var FunctionLogsResponseSchema = exports_external.array(FunctionLogEntrySchema);
 
 // src/core/resources/function/api.ts
-function toDeployPayloadItem(fn) {
-  return {
-    name: fn.name,
-    entry: fn.entry,
-    files: fn.files,
-    automations: fn.automations
-  };
-}
-async function deployFunctions(functions) {
+async function deploySingleFunction(name2, payload) {
   const appClient = getAppClient();
-  const payload = {
-    functions: functions.map(toDeployPayloadItem)
-  };
   let response;
   try {
-    response = await appClient.put("backend-functions", {
-      json: payload,
-      timeout: false
+    response = await appClient.put(`backend-functions/${encodeURIComponent(name2)}`, { json: payload, timeout: false });
+  } catch (error48) {
+    throw await ApiError.fromHttpError(error48, `deploying function "${name2}"`);
+  }
+  const result = DeploySingleFunctionResponseSchema.safeParse(await response.json());
+  if (!result.success) {
+    throw new SchemaValidationError("Invalid response from server", result.error);
+  }
+  return result.data;
+}
+async function deleteSingleFunction(name2) {
+  const appClient = getAppClient();
+  try {
+    await appClient.delete(`backend-functions/${encodeURIComponent(name2)}`, {
+      timeout: 60000
     });
   } catch (error48) {
-    throw await ApiError.fromHttpError(error48, "deploying functions");
+    throw await ApiError.fromHttpError(error48, `deleting function "${name2}"`);
+  }
+}
+async function listDeployedFunctions() {
+  const appClient = getAppClient();
+  let response;
+  try {
+    response = await appClient.get("backend-functions", { timeout: 30000 });
+  } catch (error48) {
+    throw await ApiError.fromHttpError(error48, "listing deployed functions");
   }
-  const result = DeployFunctionsResponseSchema.safeParse(await response.json());
+  const result = ListFunctionsResponseSchema.safeParse(await response.json());
   if (!result.success) {
     throw new SchemaValidationError("Invalid response from server", result.error);
   }
@@ -238409,24 +238432,135 @@ async function readAllFunctions(functionsDir) {
 import { dirname as dirname4, relative as relative2 } from "node:path";
 async function loadFunctionCode(fn) {
   const functionDir = dirname4(fn.entryPath);
-  const loadedFiles = await Promise.all(fn.filePaths.map(async (filePath) => {
+  const resolvedFiles = await Promise.all(fn.filePaths.map(async (filePath) => {
     const content = await readTextFile(filePath);
     const path11 = relative2(functionDir, filePath).split(/[/\\]/).join("/");
     return { path: path11, content };
   }));
-  return { ...fn, files: loadedFiles };
+  return { ...fn, files: resolvedFiles };
 }
-async function pushFunctions(functions) {
-  if (functions.length === 0) {
-    return { deployed: [], deleted: [], skipped: [], errors: null };
+async function deployOne(fn) {
+  const start = Date.now();
+  try {
+    const functionWithCode = await loadFunctionCode(fn);
+    const response = await deploySingleFunction(functionWithCode.name, {
+      entry: functionWithCode.entry,
+      files: functionWithCode.files,
+      automations: functionWithCode.automations
+    });
+    return {
+      name: functionWithCode.name,
+      status: response.status,
+      durationMs: Date.now() - start
+    };
+  } catch (error48) {
+    return {
+      name: fn.name,
+      status: "error",
+      error: error48 instanceof Error ? error48.message : String(error48)
+    };
+  }
+}
+async function deployFunctionsSequentially(functions, options) {
+  if (functions.length === 0)
+    return [];
+  const results = [];
+  for (const fn of functions) {
+    options?.onStart?.([fn.name]);
+    const result = await deployOne(fn);
+    results.push(result);
+    options?.onResult?.(result);
+  }
+  return results;
+}
+async function pruneRemovedFunctions(localFunctionNames, options) {
+  const remote = await listDeployedFunctions();
+  const localSet = new Set(localFunctionNames);
+  const toDelete = remote.functions.filter((f) => !localSet.has(f.name));
+  options?.onStart?.(toDelete.length);
+  const results = [];
+  for (const fn of toDelete) {
+    options?.onBeforeDelete?.(fn.name);
+    let result;
+    try {
+      await deleteSingleFunction(fn.name);
+      result = { name: fn.name, deleted: true };
+    } catch (error48) {
+      result = {
+        name: fn.name,
+        deleted: false,
+        error: error48 instanceof Error ? error48.message : String(error48)
+      };
+    }
+    results.push(result);
+    options?.onResult?.(result);
+  }
+  return results;
+}
+// src/core/resources/function/pull.ts
+import { join as join6 } from "node:path";
+import { isDeepStrictEqual as isDeepStrictEqual3 } from "node:util";
+async function writeFunctions(functionsDir, functions) {
+  const written = [];
+  const skipped = [];
+  for (const fn of functions) {
+    const functionDir = join6(functionsDir, fn.name);
+    const configPath = join6(functionDir, "function.jsonc");
+    if (await isFunctionUnchanged(functionDir, fn)) {
+      skipped.push(fn.name);
+      continue;
+    }
+    const config5 = {
+      name: fn.name,
+      entry: fn.entry
+    };
+    if (fn.automations.length > 0) {
+      config5.automations = fn.automations;
+    }
+    await writeJsonFile(configPath, config5);
+    for (const file2 of fn.files) {
+      await writeFile(join6(functionDir, file2.path), file2.content);
+    }
+    written.push(fn.name);
+  }
+  return { written, skipped };
+}
+async function isFunctionUnchanged(functionDir, fn) {
+  if (!await pathExists(functionDir)) {
+    return false;
+  }
+  const configPath = join6(functionDir, "function.jsonc");
+  try {
+    const localConfig = await readJsonFile(configPath);
+    if (localConfig.entry !== fn.entry) {
+      return false;
+    }
+    if (!isDeepStrictEqual3(localConfig.automations ?? [], fn.automations)) {
+      return false;
+    }
+  } catch {
+    return false;
+  }
+  for (const file2 of fn.files) {
+    const filePath = join6(functionDir, file2.path);
+    if (!await pathExists(filePath)) {
+      return false;
+    }
+    try {
+      const localContent = await readTextFile(filePath);
+      if (localContent !== file2.content) {
+        return false;
+      }
+    } catch {
+      return false;
+    }
   }
-  const functionsWithCode = await Promise.all(functions.map(loadFunctionCode));
-  return deployFunctions(functionsWithCode);
+  return true;
 }
 // src/core/resources/function/resource.ts
 var functionResource = {
   readAll: readAllFunctions,
-  push: pushFunctions
+  push: (functions) => deployFunctionsSequentially(functions)
 };
 // src/core/project/config.ts
 async function findConfigInDir(dir) {
@@ -238467,10 +238601,10 @@ async function readProjectConfig(projectRoot) {
   const project = result.data;
   const configDir = dirname5(configPath);
   const [entities, functions, agents, connectors] = await Promise.all([
-    entityResource.readAll(join6(configDir, project.entitiesDir)),
-    functionResource.readAll(join6(configDir, project.functionsDir)),
-    agentResource.readAll(join6(configDir, project.agentsDir)),
-    connectorResource.readAll(join6(configDir, project.connectorsDir))
+    entityResource.readAll(join7(configDir, project.entitiesDir)),
+    functionResource.readAll(join7(configDir, project.functionsDir)),
+    agentResource.readAll(join7(configDir, project.agentsDir)),
+    connectorResource.readAll(join7(configDir, project.connectorsDir))
   ]);
   return {
     project: { ...project, root, configPath },
@@ -238567,16 +238701,16 @@ async function readAppConfig(projectRoot) {
 // src/core/project/template.ts
 var import_ejs = __toESM(require_ejs(), 1);
 var import_front_matter = __toESM(require_front_matter(), 1);
-import { dirname as dirname6, join as join8 } from "node:path";
+import { dirname as dirname6, join as join9 } from "node:path";
 
 // src/core/assets.ts
 import { cpSync, existsSync } from "node:fs";
 import { homedir as homedir2 } from "node:os";
-import { join as join7 } from "node:path";
+import { join as join8 } from "node:path";
 // package.json
 var package_default = {
   name: "base44",
-  version: "0.0.44",
+  version: "0.0.45",
   description: "Base44 CLI - Unified interface for managing Base44 applications",
   type: "module",
   bin: {
@@ -238665,15 +238799,15 @@ var package_default = {
 };
 
 // src/core/assets.ts
-var ASSETS_DIR = join7(homedir2(), ".base44", "assets", package_default.version);
+var ASSETS_DIR = join8(homedir2(), ".base44", "assets", package_default.version);
 function getTemplatesDir() {
-  return join7(ASSETS_DIR, "templates");
+  return join8(ASSETS_DIR, "templates");
 }
 function getTemplatesIndexPath() {
-  return join7(ASSETS_DIR, "templates", "templates.json");
+  return join8(ASSETS_DIR, "templates", "templates.json");
 }
 function getDenoWrapperPath() {
-  return join7(ASSETS_DIR, "deno-runtime", "main.js");
+  return join8(ASSETS_DIR, "deno-runtime", "main.ts");
 }
 function ensureNpmAssets(sourceDir) {
   if (existsSync(ASSETS_DIR))
@@ -238694,23 +238828,23 @@ async function listTemplates() {
   return result.data.templates;
 }
 async function renderTemplate(template, destPath, data) {
-  const templateDir = join8(getTemplatesDir(), template.path);
+  const templateDir = join9(getTemplatesDir(), template.path);
   const files = await globby("**/*", {
     cwd: templateDir,
     dot: true,
     onlyFiles: true
   });
   for (const file2 of files) {
-    const srcPath = join8(templateDir, file2);
+    const srcPath = join9(templateDir, file2);
     try {
       if (file2.endsWith(".ejs")) {
         const rendered = await import_ejs.default.renderFile(srcPath, data);
         const { attributes, body } = import_front_matter.default(rendered);
-        const destFile = attributes.outputFileName ? join8(dirname6(file2), attributes.outputFileName) : file2.replace(/\.ejs$/, "");
-        const destFilePath = join8(destPath, destFile);
+        const destFile = attributes.outputFileName ? join9(dirname6(file2), attributes.outputFileName) : file2.replace(/\.ejs$/, "");
+        const destFilePath = join9(destPath, destFile);
         await writeFile(destFilePath, body);
       } else {
-        const destFilePath = join8(destPath, file2);
+        const destFilePath = join9(destPath, file2);
         await copyFile(srcPath, destFilePath);
       }
     } catch (error48) {
@@ -238809,7 +238943,7 @@ async function getSiteFilePaths(outputDir) {
 // src/core/site/deploy.ts
 import { randomUUID } from "node:crypto";
 import { tmpdir } from "node:os";
-import { join as join9 } from "node:path";
+import { join as join10 } from "node:path";
 async function deploySite(siteOutputDir) {
   if (!await pathExists(siteOutputDir)) {
     throw new InvalidInputError(`Output directory does not exist: ${siteOutputDir}. Make sure to build your project first.`, {
@@ -238826,7 +238960,7 @@ async function deploySite(siteOutputDir) {
       ]
     });
   }
-  const archivePath = join9(tmpdir(), `base44-site-${randomUUID()}.tar.gz`);
+  const archivePath = join10(tmpdir(), `base44-site-${randomUUID()}.tar.gz`);
   try {
     await createArchive(siteOutputDir, archivePath);
     return await uploadSite(archivePath);
@@ -238851,10 +238985,13 @@ function hasResourcesToDeploy(projectData) {
   const hasConnectors = connectors.length > 0;
   return hasEntities || hasFunctions || hasAgents || hasConnectors || hasSite;
 }
-async function deployAll(projectData) {
+async function deployAll(projectData, options) {
   const { project, entities, functions, agents, connectors } = projectData;
   await entityResource.push(entities);
-  await functionResource.push(functions);
+  await deployFunctionsSequentially(functions, {
+    onStart: options?.onFunctionStart,
+    onResult: options?.onFunctionResult
+  });
   await agentResource.push(agents);
   const { results: connectorResults } = await pushConnectors(connectors);
   if (project.site?.outputDirectory) {
@@ -246611,7 +246748,7 @@ function formatYaml(data, options = {}) {
 async function pullAgentsAction() {
   const { project: project2 } = await readProjectConfig();
   const configDir = dirname7(project2.configPath);
-  const agentsDir = join10(configDir, project2.agentsDir);
+  const agentsDir = join11(configDir, project2.agentsDir);
   const remoteAgents = await runTask("Fetching agents from Base44", async () => {
     return await fetchAgents();
   }, {
@@ -246733,11 +246870,11 @@ function getConnectorsListAvailableCommand(context) {
 }
 
 // src/cli/commands/connectors/pull.ts
-import { dirname as dirname8, join as join11 } from "node:path";
+import { dirname as dirname8, join as join12 } from "node:path";
 async function pullConnectorsAction() {
   const { project: project2 } = await readProjectConfig();
   const configDir = dirname8(project2.configPath);
-  const connectorsDir = join11(configDir, project2.connectorsDir);
+  const connectorsDir = join12(configDir, project2.connectorsDir);
   const remoteConnectors = await runTask("Fetching connectors from Base44", async () => {
     return await pullAllConnectors();
   }, {
@@ -247606,46 +247743,242 @@ function getEntitiesPushCommand(context) {
   }));
 }
 
+// src/cli/commands/functions/delete.ts
+async function deleteFunctionsAction(names) {
+  let deleted = 0;
+  let notFound = 0;
+  let errors5 = 0;
+  for (const name2 of names) {
+    try {
+      await runTask(`Deleting ${name2}...`, () => deleteSingleFunction(name2), {
+        successMessage: `${name2} deleted`,
+        errorMessage: `Failed to delete ${name2}`
+      });
+      deleted++;
+    } catch (error48) {
+      if (error48 instanceof ApiError && error48.statusCode === 404) {
+        notFound++;
+      } else {
+        errors5++;
+      }
+    }
+  }
+  if (names.length === 1) {
+    if (deleted)
+      return { outroMessage: `Function "${names[0]}" deleted` };
+    if (notFound)
+      return { outroMessage: `Function "${names[0]}" not found` };
+    return { outroMessage: `Failed to delete "${names[0]}"` };
+  }
+  const total = names.length;
+  const parts = [];
+  if (deleted > 0)
+    parts.push(`${deleted}/${total} deleted`);
+  if (notFound > 0)
+    parts.push(`${notFound} not found`);
+  if (errors5 > 0)
+    parts.push(`${errors5} error${errors5 !== 1 ? "s" : ""}`);
+  return { outroMessage: parts.join(", ") };
+}
+function parseNames(args) {
+  return args.flatMap((arg) => arg.split(",")).map((n2) => n2.trim()).filter(Boolean);
+}
+function validateNames(command) {
+  const names = parseNames(command.args);
+  if (names.length === 0) {
+    command.error("At least one function name is required");
+  }
+}
+function getDeleteCommand(context) {
+  return new Command("delete").description("Delete deployed functions").argument("<names...>", "Function names to delete").hook("preAction", validateNames).action(async (rawNames) => {
+    const names = parseNames(rawNames);
+    await runCommand(() => deleteFunctionsAction(names), { requireAuth: true }, context);
+  });
+}
+
+// src/cli/commands/functions/formatDeployResult.ts
+function formatDuration(ms) {
+  return `${(ms / 1000).toFixed(1)}s`;
+}
+function formatDeployResult(result) {
+  const label = result.name.padEnd(25);
+  if (result.status === "deployed") {
+    const timing = result.durationMs ? theme.styles.dim(` (${formatDuration(result.durationMs)})`) : "";
+    R2.success(`${label} deployed${timing}`);
+  } else if (result.status === "unchanged") {
+    R2.success(`${label} unchanged`);
+  } else {
+    R2.error(`${label} error: ${result.error}`);
+  }
+}
+
+// src/cli/commands/functions/parseNames.ts
+function parseNames2(args) {
+  return args.flatMap((arg) => arg.split(",")).map((n2) => n2.trim()).filter(Boolean);
+}
+
 // src/cli/commands/functions/deploy.ts
-async function deployFunctionsAction() {
+function resolveFunctionsToDeploy(names, allFunctions) {
+  if (names.length === 0)
+    return allFunctions;
+  const notFound = names.filter((n2) => !allFunctions.some((f) => f.name === n2));
+  if (notFound.length > 0) {
+    throw new InvalidInputError(`Function${notFound.length > 1 ? "s" : ""} not found in project: ${notFound.join(", ")}`);
+  }
+  return allFunctions.filter((f) => names.includes(f.name));
+}
+function formatPruneResult(pruneResult) {
+  if (pruneResult.deleted) {
+    R2.success(`${pruneResult.name.padEnd(25)} deleted`);
+  } else {
+    R2.error(`${pruneResult.name.padEnd(25)} error: ${pruneResult.error}`);
+  }
+}
+function formatPruneSummary(pruneResults) {
+  if (pruneResults.length > 0) {
+    const pruned = pruneResults.filter((r) => r.deleted).length;
+    R2.info(`${pruned} deleted`);
+  }
+}
+function buildDeploySummary(results) {
+  const deployed = results.filter((r) => r.status === "deployed").length;
+  const unchanged = results.filter((r) => r.status === "unchanged").length;
+  const failed = results.filter((r) => r.status === "error").length;
+  const parts = [];
+  if (deployed > 0)
+    parts.push(`${deployed} deployed`);
+  if (unchanged > 0)
+    parts.push(`${unchanged} unchanged`);
+  if (failed > 0)
+    parts.push(`${failed} error${failed !== 1 ? "s" : ""}`);
+  return parts.join(", ") || "No functions deployed";
+}
+async function deployFunctionsAction(names, options) {
+  if (options.force && names.length > 0) {
+    throw new InvalidInputError("--force cannot be used when specifying function names");
+  }
   const { functions } = await readProjectConfig();
-  if (functions.length === 0) {
+  const toDeploy = resolveFunctionsToDeploy(names, functions);
+  if (toDeploy.length === 0) {
     return {
       outroMessage: "No functions found. Create functions in the 'functions' directory."
     };
   }
-  R2.info(`Found ${functions.length} ${functions.length === 1 ? "function" : "functions"} to deploy`);
-  const result = await runTask("Deploying functions to Base44", async () => {
-    return await pushFunctions(functions);
+  R2.info(`Found ${toDeploy.length} ${toDeploy.length === 1 ? "function" : "functions"} to deploy`);
+  let completed = 0;
+  const total = toDeploy.length;
+  const results = await deployFunctionsSequentially(toDeploy, {
+    onStart: (startNames) => {
+      const label = startNames.length === 1 ? startNames[0] : `${startNames.length} functions`;
+      R2.step(theme.styles.dim(`[${completed + 1}/${total}] Deploying ${label}...`));
+    },
+    onResult: (result) => {
+      completed++;
+      formatDeployResult(result);
+    }
+  });
+  if (options.force) {
+    const allLocalNames = functions.map((f) => f.name);
+    let pruneCompleted = 0;
+    let pruneTotal = 0;
+    const pruneResults = await pruneRemovedFunctions(allLocalNames, {
+      onStart: (total2) => {
+        pruneTotal = total2;
+        if (total2 > 0) {
+          R2.info(`Found ${total2} remote ${total2 === 1 ? "function" : "functions"} to delete`);
+        }
+      },
+      onBeforeDelete: (name2) => {
+        pruneCompleted++;
+        R2.step(theme.styles.dim(`[${pruneCompleted}/${pruneTotal}] Deleting ${name2}...`));
+      },
+      onResult: formatPruneResult
+    });
+    formatPruneSummary(pruneResults);
+  }
+  return { outroMessage: buildDeploySummary(results) };
+}
+function getDeployCommand(context) {
+  return new Command("deploy").description("Deploy functions to Base44").argument("[names...]", "Function names to deploy (deploys all if omitted)").option("--force", "Delete remote functions not found locally").action(async (rawNames, options) => {
+    await runCommand(() => {
+      const names = parseNames2(rawNames);
+      return deployFunctionsAction(names, options);
+    }, { requireAuth: true }, context);
+  });
+}
+
+// src/cli/commands/functions/list.ts
+async function listFunctionsAction() {
+  const { functions } = await runTask("Fetching functions...", async () => listDeployedFunctions(), { errorMessage: "Failed to fetch functions" });
+  if (functions.length === 0) {
+    return { outroMessage: "No functions on remote" };
+  }
+  for (const fn of functions) {
+    const automationCount = fn.automations.length;
+    const automationLabel = automationCount > 0 ? theme.styles.dim(` (${automationCount} automation${automationCount > 1 ? "s" : ""})`) : "";
+    R2.message(`  ${fn.name}${automationLabel}`);
+  }
+  return {
+    outroMessage: `${functions.length} function${functions.length !== 1 ? "s" : ""} on remote`
+  };
+}
+function getListCommand(context) {
+  return new Command("list").description("List all deployed functions").action(async () => {
+    await runCommand(listFunctionsAction, { requireAuth: true }, context);
+  });
+}
+
+// src/cli/commands/functions/pull.ts
+import { dirname as dirname9, join as join13 } from "node:path";
+async function pullFunctionsAction(name2) {
+  const { project: project2 } = await readProjectConfig();
+  const configDir = dirname9(project2.configPath);
+  const functionsDir = join13(configDir, project2.functionsDir);
+  const remoteFunctions = await runTask("Fetching functions from Base44", async () => {
+    const { functions } = await listDeployedFunctions();
+    return functions;
   }, {
-    successMessage: "Functions deployed successfully",
-    errorMessage: "Failed to deploy functions"
+    successMessage: "Functions fetched successfully",
+    errorMessage: "Failed to fetch functions"
   });
-  if (result.deployed.length > 0) {
-    R2.success(`Deployed: ${result.deployed.join(", ")}`);
+  const toPull = name2 ? remoteFunctions.filter((f) => f.name === name2) : remoteFunctions;
+  if (name2 && toPull.length === 0) {
+    return {
+      outroMessage: `Function "${name2}" not found on remote`
+    };
   }
-  if (result.deleted.length > 0) {
-    R2.warn(`Deleted: ${result.deleted.join(", ")}`);
+  if (toPull.length === 0) {
+    return { outroMessage: "No functions found on remote" };
   }
-  if (result.errors && result.errors.length > 0) {
-    throw new ApiError("Function deployment errors", {
-      details: result.errors.map((e2) => `'${e2.name}': ${e2.message}`),
-      hints: [
-        { message: "Check the function code for syntax errors" },
-        { message: "Ensure all imports are valid" }
-      ]
-    });
+  const { written, skipped } = await runTask("Writing function files", async () => {
+    return await writeFunctions(functionsDir, toPull);
+  }, {
+    successMessage: "Function files written successfully",
+    errorMessage: "Failed to write function files"
+  });
+  for (const name3 of written) {
+    R2.success(`${name3.padEnd(25)} written`);
+  }
+  for (const name3 of skipped) {
+    R2.info(`${name3.padEnd(25)} unchanged`);
   }
-  return { outroMessage: "Functions deployed to Base44" };
+  return {
+    outroMessage: `Pulled ${toPull.length} function${toPull.length !== 1 ? "s" : ""} to ${functionsDir}`
+  };
 }
-function getFunctionsDeployCommand(context) {
-  return new Command("functions").description("Manage project functions").addCommand(new Command("deploy").description("Deploy local functions to Base44").action(async () => {
-    await runCommand(deployFunctionsAction, { requireAuth: true }, context);
-  }));
+function getPullCommand(context) {
+  return new Command("pull").description("Pull deployed functions from Base44").argument("[name]", "Function name to pull (pulls all if omitted)").action(async (name2) => {
+    await runCommand(() => pullFunctionsAction(name2), { requireAuth: true }, context);
+  });
+}
+
+// src/cli/commands/functions/index.ts
+function getFunctionsCommand(context) {
+  return new Command("functions").description("Manage backend functions").addCommand(getDeployCommand(context)).addCommand(getDeleteCommand(context)).addCommand(getListCommand(context)).addCommand(getPullCommand(context));
 }
 
 // src/cli/commands/project/create.ts
-import { basename as basename3, join as join12, resolve as resolve2 } from "node:path";
+import { basename as basename3, join as join14, resolve as resolve2 } from "node:path";
 var import_kebabCase = __toESM(require_kebabCase(), 1);
 var DEFAULT_TEMPLATE_ID = "backend-only";
 async function getTemplateById(templateId) {
@@ -247782,7 +248115,7 @@ async function executeCreate({
         updateMessage("Building project...");
         await execa({ cwd: resolvedPath, shell: true })`${buildCommand}`;
         updateMessage("Deploying site...");
-        return await deploySite(join12(resolvedPath, outputDirectory));
+        return await deploySite(join14(resolvedPath, outputDirectory));
       }, {
         successMessage: theme.colors.base44Orange("Site deployed successfully"),
         errorMessage: "Failed to deploy site"
@@ -247869,11 +248202,17 @@ ${summaryLines.join(`
 ${summaryLines.join(`
 `)}`);
   }
-  const result = await runTask("Deploying your app...", async () => {
-    return await deployAll(projectData);
-  }, {
-    successMessage: theme.colors.base44Orange("Deployment completed"),
-    errorMessage: "Deployment failed"
+  let functionCompleted = 0;
+  const functionTotal = functions.length;
+  const result = await deployAll(projectData, {
+    onFunctionStart: (names) => {
+      const label = names.length === 1 ? names[0] : `${names.length} functions`;
+      R2.step(theme.styles.dim(`[${functionCompleted + 1}/${functionTotal}] Deploying ${label}...`));
+    },
+    onFunctionResult: (r) => {
+      functionCompleted++;
+      formatDeployResult(r);
+    }
   });
   const connectorResults = result.connectorResults ?? [];
   await handleOAuthConnectors(connectorResults, options);
@@ -247887,7 +248226,7 @@ ${summaryLines.join(`
   }
   return { outroMessage: "App deployed successfully" };
 }
-function getDeployCommand(context) {
+function getDeployCommand2(context) {
   return new Command("deploy").description("Deploy all project resources (entities, functions, agents, connectors, and site)").option("-y, --yes", "Skip confirmation prompt").action(async (options) => {
     await runCommand(() => deployAction({
       ...options,
@@ -248432,10 +248771,10 @@ function toPascalCase(name2) {
   return name2.split(/[-_\s]+/).map((w8) => w8.charAt(0).toUpperCase() + w8.slice(1)).join("");
 }
 // src/core/types/update-project.ts
-import { join as join15 } from "node:path";
+import { join as join17 } from "node:path";
 var TYPES_INCLUDE_PATH = `${PROJECT_SUBDIR}/${TYPES_OUTPUT_SUBDIR}/*.d.ts`;
 async function updateProjectConfig(projectRoot) {
-  const tsconfigPath = join15(projectRoot, "tsconfig.json");
+  const tsconfigPath = join17(projectRoot, "tsconfig.json");
   if (!await pathExists(tsconfigPath)) {
     return false;
   }
@@ -248478,7 +248817,7 @@ function getTypesCommand(context) {
 }
 
 // src/cli/dev/dev-server/main.ts
-import { dirname as dirname13, join as join18 } from "node:path";
+import { dirname as dirname14, join as join20 } from "node:path";
 var import_cors = __toESM(require_lib4(), 1);
 var import_express4 = __toESM(require_express(), 1);
 
@@ -248604,6 +248943,7 @@ var { promisify: promisify11 } = __require("util");
 var tmp = require_tmp();
 var $fileSync = tmp.fileSync;
 var fileWithOptions = promisify11((options8, cb2) => tmp.file(options8, (err, path18, fd, cleanup) => err ? cb2(err) : cb2(undefined, { path: path18, fd, cleanup: promisify11(cleanup) })));
+var $file = async (options8) => fileWithOptions(options8);
 var $dirSync = tmp.dirSync;
 var dirWithOptions = promisify11((options8, cb2) => tmp.dir(options8, (err, path18, cleanup) => err ? cb2(err) : cb2(undefined, { path: path18, cleanup: promisify11(cleanup) })));
 var $dir = async (options8) => dirWithOptions(options8);
@@ -248636,7 +248976,85 @@ function createDevLogger() {
 }
 
 // src/cli/dev/dev-server/function-manager.ts
+import { spawn as spawn3 } from "node:child_process";
+
+// src/core/exec/run-script.ts
 import { spawn as spawn2, spawnSync as spawnSync2 } from "node:child_process";
+import { copyFileSync, writeFileSync as writeFileSync2 } from "node:fs";
+import { resolve as resolve6 } from "node:path";
+function verifyDenoInstalled() {
+  const result = spawnSync2("deno", ["--version"]);
+  if (result.error) {
+    throw new DependencyNotFoundError("Deno is required to run scripts with exec", {
+      hints: [
+        {
+          message: "Install Deno: https://docs.deno.com/runtime/getting_started/installation/"
+        }
+      ]
+    });
+  }
+}
+async function getUserAppToken() {
+  try {
+    const response = await getAppClient().get("auth/token").json();
+    return response.token;
+  } catch (error48) {
+    throw await ApiError.fromHttpError(error48, "exchanging platform token for app user token");
+  }
+}
+async function runScript(options8) {
+  const { filePath, code: code2, extraArgs = [], execWrapperPath } = options8;
+  verifyDenoInstalled();
+  const cleanupFns = [];
+  let scriptPath;
+  if (filePath) {
+    scriptPath = `file://${resolve6(filePath)}`;
+  } else if (code2 !== undefined) {
+    const tempScript = await $file({ postfix: ".ts" });
+    cleanupFns.push(tempScript.cleanup);
+    writeFileSync2(tempScript.path, code2, "utf-8");
+    scriptPath = `file://${tempScript.path}`;
+  } else {
+    throw new Error("Either filePath or code must be provided");
+  }
+  const appConfig = getAppConfig();
+  const [appUserToken, appBaseUrl] = await Promise.all([
+    getUserAppToken(),
+    getSiteUrl()
+  ]);
+  const tempWrapper = await $file({ postfix: ".ts" });
+  cleanupFns.push(tempWrapper.cleanup);
+  copyFileSync(execWrapperPath, tempWrapper.path);
+  try {
+    const exitCode = await new Promise((resolvePromise) => {
+      const child = spawn2("deno", [
+        "run",
+        "--allow-all",
+        "--node-modules-dir=auto",
+        tempWrapper.path,
+        ...extraArgs
+      ], {
+        env: {
+          ...process.env,
+          SCRIPT_PATH: scriptPath,
+          BASE44_APP_ID: appConfig.id,
+          BASE44_ACCESS_TOKEN: appUserToken,
+          BASE44_APP_BASE_URL: appBaseUrl
+        },
+        stdio: "inherit"
+      });
+      child.on("close", (code3) => {
+        resolvePromise(code3 ?? 1);
+      });
+    });
+    return { exitCode };
+  } finally {
+    for (const cleanup of cleanupFns) {
+      cleanup();
+    }
+  }
+}
+// src/cli/dev/dev-server/function-manager.ts
 var READY_TIMEOUT = 30000;
 
 class FunctionManager {
@@ -248650,15 +249068,7 @@ class FunctionManager {
     this.logger = logger;
     this.wrapperPath = wrapperPath;
     if (functions.length > 0) {
-      this.verifyDenoIsInstalled();
-    }
-  }
-  verifyDenoIsInstalled() {
-    const result = spawnSync2("deno", ["--version"]);
-    if (result.error) {
-      throw new DependencyNotFoundError("Deno is required to run functions", {
-        hints: [{ message: "Install Deno from https://deno.com/download" }]
-      });
+      verifyDenoInstalled();
     }
   }
   getFunctionNames() {
@@ -248721,7 +249131,7 @@ class FunctionManager {
   }
   spawnFunction(func, port) {
     this.logger.log(`Spawning function "${func.name}" on port ${port}`);
-    const process21 = spawn2("deno", ["run", "--allow-all", this.wrapperPath], {
+    const process21 = spawn3("deno", ["run", "--allow-all", this.wrapperPath], {
       env: {
         ...globalThis.process.env,
         FUNCTION_PATH: func.entryPath,
@@ -248759,7 +249169,7 @@ class FunctionManager {
     });
   }
   waitForReady(name2, runningFunc) {
-    return new Promise((resolve6, reject) => {
+    return new Promise((resolve7, reject) => {
       runningFunc.process.on("exit", (code2) => {
         if (!runningFunc.ready) {
           clearTimeout(timeout3);
@@ -248782,7 +249192,7 @@ class FunctionManager {
           runningFunc.ready = true;
           clearTimeout(timeout3);
           runningFunc.process.stdout?.off("data", onData);
-          resolve6(runningFunc.port);
+          resolve7(runningFunc.port);
         }
       };
       runningFunc.process.stdout?.on("data", onData);
@@ -248835,14 +249245,163 @@ function createFunctionRouter(manager, logger) {
   return router;
 }
 
-// src/cli/dev/dev-server/database.ts
+// src/cli/dev/dev-server/db/database.ts
 var import_nedb = __toESM(require_nedb(), 1);
 
+// src/cli/dev/dev-server/db/validator.ts
+var fieldTypes = [
+  "string",
+  "integer",
+  "number",
+  "boolean",
+  "array",
+  "object"
+];
+
+class Validator {
+  filterFields(record2, entitySchema) {
+    const filteredRecord = {};
+    for (const [key2, value] of Object.entries(record2)) {
+      if (entitySchema.properties[key2]) {
+        filteredRecord[key2] = value;
+      }
+    }
+    return filteredRecord;
+  }
+  applyDefaults(record2, entitySchema) {
+    const result = {};
+    for (const [key2, property] of Object.entries(entitySchema.properties)) {
+      if (property.default !== undefined) {
+        result[key2] = property.default;
+      }
+    }
+    return {
+      ...result,
+      ...record2
+    };
+  }
+  validate(record2, entitySchema, partial2 = false) {
+    if (!partial2) {
+      const requiredFieldsResponse = this.validateRequiredFields(record2, entitySchema);
+      if (requiredFieldsResponse.hasError) {
+        return requiredFieldsResponse;
+      }
+    }
+    const fieldTypesResponse = this.validateFieldTypes(record2, entitySchema);
+    if (fieldTypesResponse.hasError) {
+      return fieldTypesResponse;
+    }
+    return {
+      hasError: false
+    };
+  }
+  createValidationError(message) {
+    return {
+      error_type: "ValidationError",
+      message,
+      request_id: null,
+      traceback: ""
+    };
+  }
+  validateFieldTypes(record2, entitySchema) {
+    for (const [key2, value] of Object.entries(record2)) {
+      const property = entitySchema.properties[key2];
+      const result = this.validateValue(value, property, key2);
+      if (result.hasError)
+        return result;
+    }
+    return {
+      hasError: false
+    };
+  }
+  validateValue(value, property, fieldPath) {
+    if (!property) {
+      return { hasError: false };
+    }
+    const propertyType = property.type;
+    if (!fieldTypes.includes(propertyType)) {
+      return {
+        hasError: true,
+        error: this.createValidationError(`Error in field ${fieldPath}: Unsupported field type ${propertyType}`)
+      };
+    }
+    switch (propertyType) {
+      case "array":
+        if (!Array.isArray(value)) {
+          return {
+            hasError: true,
+            error: this.createValidationError(`Error in field ${fieldPath}: Input should be a valid array`)
+          };
+        }
+        if (property.items) {
+          for (let i5 = 0;i5 < value.length; i5++) {
+            const itemResult = this.validateValue(value[i5], property.items, `${fieldPath}[${i5}]`);
+            if (itemResult.hasError)
+              return itemResult;
+          }
+        }
+        break;
+      case "object":
+        if (typeof value !== "object" || value === null || Array.isArray(value)) {
+          return {
+            hasError: true,
+            error: this.createValidationError(`Error in field ${fieldPath}: Input should be a valid object`)
+          };
+        }
+        if (property.properties) {
+          for (const [subKey, subValue] of Object.entries(value)) {
+            if (property.properties[subKey]) {
+              const subResult = this.validateValue(subValue, property.properties[subKey], `${fieldPath}.${subKey}`);
+              if (subResult.hasError)
+                return subResult;
+            }
+          }
+        }
+        break;
+      case "integer":
+        if (!Number.isInteger(value)) {
+          return {
+            hasError: true,
+            error: this.createValidationError(`Error in field ${fieldPath}: Input should be a valid integer`)
+          };
+        }
+        break;
+      default:
+        if (typeof value !== propertyType) {
+          return {
+            hasError: true,
+            error: this.createValidationError(`Error in field ${fieldPath}: Input should be a valid ${propertyType}`)
+          };
+        }
+    }
+    return { hasError: false };
+  }
+  validateRequiredFields(record2, entitySchema) {
+    if (entitySchema.required && entitySchema.required.length > 0) {
+      for (const required2 of entitySchema.required) {
+        if (record2[required2] == null) {
+          return {
+            hasError: true,
+            error: this.createValidationError(`Error in field ${required2}: Field required`)
+          };
+        }
+      }
+    }
+    return {
+      hasError: false
+    };
+  }
+}
+
+// src/cli/dev/dev-server/db/database.ts
 class Database {
   collections = new Map;
+  schemas = new Map;
+  validator = new Validator;
   load(entities) {
     for (const entity2 of entities) {
       this.collections.set(entity2.name, new import_nedb.default);
+      this.schemas.set(entity2.name, entity2);
     }
   }
   getCollection(name2) {
@@ -248856,6 +249415,25 @@ class Database {
       collection.remove({}, { multi: true });
     }
     this.collections.clear();
+    this.schemas.clear();
+  }
+  validate(entityName, record2, partial2 = false) {
+    const schema9 = this.schemas.get(entityName);
+    if (!schema9) {
+      throw new Error(`Entity "${entityName}" not found`);
+    }
+    return this.validator.validate(record2, schema9, partial2);
+  }
+  prepareRecord(entityName, record2, partial2 = false) {
+    const schema9 = this.schemas.get(entityName);
+    if (!schema9) {
+      throw new Error(`Entity "${entityName}" not found`);
+    }
+    const filteredRecord = this.validator.filterFields(record2, schema9);
+    if (partial2) {
+      return filteredRecord;
+    }
+    return this.validator.applyDefaults(filteredRecord, schema9);
   }
 }
 
@@ -249047,8 +249625,14 @@ function createEntityRoutes(db2, logger, remoteProxy, broadcast) {
     try {
       const now = new Date().toISOString();
       const { _id, ...body } = req.body;
+      const filteredBody = db2.prepareRecord(entityName, body);
+      const validation = db2.validate(entityName, filteredBody);
+      if (validation.hasError) {
+        res.status(422).json(validation.error);
+        return;
+      }
       const record2 = {
-        ...body,
+        ...filteredBody,
         id: nanoid3(),
         created_date: now,
         updated_date: now
@@ -249069,12 +249653,21 @@ function createEntityRoutes(db2, logger, remoteProxy, broadcast) {
     }
     try {
       const now = new Date().toISOString();
-      const records = req.body.map((item) => ({
-        ...item,
-        id: nanoid3(),
-        created_date: now,
-        updated_date: now
-      }));
+      const records = [];
+      for (const record2 of req.body) {
+        const filteredRecord = db2.prepareRecord(entityName, record2);
+        const validation = db2.validate(entityName, filteredRecord);
+        if (validation.hasError) {
+          res.status(422).json(validation.error);
+          return;
+        }
+        records.push({
+          ...filteredRecord,
+          id: nanoid3(),
+          created_date: now,
+          updated_date: now
+        });
+      }
       const inserted = stripInternalFields(await collection.insertAsync(records));
       emit(appId, entityName, "create", inserted);
       res.status(201).json(inserted);
@@ -249087,8 +249680,14 @@ function createEntityRoutes(db2, logger, remoteProxy, broadcast) {
     const { appId, entityName, id: id2 } = req.params;
     const { id: _id, created_date: _created_date, ...body } = req.body;
     try {
+      const filteredBody = db2.prepareRecord(entityName, body, true);
+      const validation = db2.validate(entityName, filteredBody, true);
+      if (validation.hasError) {
+        res.status(422).json(validation.error);
+        return;
+      }
       const updateData = {
-        ...body,
+        ...filteredBody,
         updated_date: new Date().toISOString()
       };
       const result = await collection.updateAsync({ id: id2 }, { $set: updateData }, { returnUpdatedDocs: true });
@@ -249958,9 +250557,9 @@ class NodeFsHandler {
     if (this.fsw.closed) {
       return;
     }
-    const dirname12 = sp2.dirname(file2);
+    const dirname13 = sp2.dirname(file2);
     const basename5 = sp2.basename(file2);
-    const parent = this.fsw._getWatchedDir(dirname12);
+    const parent = this.fsw._getWatchedDir(dirname13);
     let prevStats = stats;
     if (parent.has(basename5))
       return;
@@ -249987,7 +250586,7 @@ class NodeFsHandler {
             prevStats = newStats2;
           }
         } catch (error48) {
-          this.fsw._remove(dirname12, basename5);
+          this.fsw._remove(dirname13, basename5);
         }
       } else if (parent.has(basename5)) {
         const at13 = newStats.atimeMs;
@@ -250076,7 +250675,7 @@ class NodeFsHandler {
         this._addToNodeFs(path19, initialAdd, wh2, depth + 1);
       }
     }).on(EV.ERROR, this._boundHandleError);
-    return new Promise((resolve7, reject) => {
+    return new Promise((resolve8, reject) => {
       if (!stream)
         return reject();
       stream.once(STR_END, () => {
@@ -250085,7 +250684,7 @@ class NodeFsHandler {
           return;
         }
         const wasThrottled = throttler ? throttler.clear() : false;
-        resolve7(undefined);
+        resolve8(undefined);
         previous.getChildren().filter((item) => {
           return item !== directory && !current.has(item);
         }).forEach((item) => {
@@ -250990,7 +251589,7 @@ async function createDevServer(options8) {
     devLogger.warn(`"${req.originalUrl}" is not supported in local development, passing call to production`);
     remoteProxy(req, res, next);
   });
-  const server = await new Promise((resolve8, reject) => {
+  const server = await new Promise((resolve9, reject) => {
     const s5 = app.listen(port, "127.0.0.1", (err) => {
       if (err) {
         if ("code" in err && err.code === "EADDRINUSE") {
@@ -250999,7 +251598,7 @@ async function createDevServer(options8) {
           reject(err);
         }
       } else {
-        resolve8(s5);
+        resolve9(s5);
       }
     });
   });
@@ -251008,8 +251607,8 @@ async function createDevServer(options8) {
     broadcastEntityEvent(io6, appId, entityName, event);
   };
   const base44ConfigWatcher = new WatchBase44({
-    functions: join18(dirname13(project2.configPath), project2.functionsDir),
-    entities: join18(dirname13(project2.configPath), project2.entitiesDir)
+    functions: join20(dirname14(project2.configPath), project2.functionsDir),
+    entities: join20(dirname14(project2.configPath), project2.entitiesDir)
   }, devLogger);
   base44ConfigWatcher.on("change", async (name2) => {
     try {
@@ -251073,8 +251672,53 @@ function getDevCommand(context) {
   });
 }
 
+// src/cli/commands/exec.ts
+import { dirname as dirname15, join as join21 } from "node:path";
+import { fileURLToPath as fileURLToPath6 } from "node:url";
+var __dirname4 = dirname15(fileURLToPath6(import.meta.url));
+var EXEC_WRAPPER_PATH = join21(__dirname4, "../deno-runtime/exec.ts");
+function readStdin() {
+  return new Promise((resolve9, reject) => {
+    let data = "";
+    process.stdin.setEncoding("utf-8");
+    process.stdin.on("data", (chunk) => {
+      data += chunk;
+    });
+    process.stdin.on("end", () => resolve9(data));
+    process.stdin.on("error", reject);
+  });
+}
+async function execAction(extraArgs) {
+  if (process.stdin.isTTY) {
+    throw new InvalidInputError("No input provided. Pipe a script to stdin.", {
+      hints: [
+        { message: "File:  cat ./script.ts | base44 exec" },
+        { message: 'Eval:  echo "console.log(1)" | base44 exec' }
+      ]
+    });
+  }
+  const code2 = await readStdin();
+  const { exitCode } = await runScript({
+    code: code2,
+    extraArgs,
+    execWrapperPath: EXEC_WRAPPER_PATH
+  });
+  if (exitCode !== 0) {
+    process.exitCode = exitCode;
+  }
+  return {};
+}
+function getExecCommand(context) {
+  const cmd = new Command("exec").description("Run a script with the Base44 SDK pre-authenticated as the current user").action(async () => {
+    const dashIndex = process.argv.indexOf("--");
+    const extraArgs = dashIndex !== -1 ? process.argv.slice(dashIndex + 1) : [];
+    await runCommand(() => execAction(extraArgs), { requireAuth: true }, context);
+  });
+  return cmd;
+}
+
 // src/cli/commands/project/eject.ts
-import { resolve as resolve8 } from "node:path";
+import { resolve as resolve9 } from "node:path";
 var import_kebabCase2 = __toESM(require_kebabCase(), 1);
 async function eject(options8) {
   const projects = await listProjects();
@@ -251123,7 +251767,7 @@ async function eject(options8) {
     Ne("Operation cancelled.");
     throw new CLIExitError(0);
   }
-  const resolvedPath = resolve8(selectedPath);
+  const resolvedPath = resolve9(selectedPath);
   await runTask("Downloading your project's code...", async (updateMessage) => {
     await createProjectFilesForExistingProject({
       projectId,
@@ -251179,16 +251823,17 @@ function createProgram(context) {
   program2.addCommand(getLogoutCommand(context));
   program2.addCommand(getCreateCommand(context));
   program2.addCommand(getDashboardCommand(context));
-  program2.addCommand(getDeployCommand(context));
+  program2.addCommand(getDeployCommand2(context));
   program2.addCommand(getLinkCommand(context));
   program2.addCommand(getEjectCommand(context));
   program2.addCommand(getEntitiesPushCommand(context));
   program2.addCommand(getAgentsCommand(context));
   program2.addCommand(getConnectorsCommand(context));
-  program2.addCommand(getFunctionsDeployCommand(context));
+  program2.addCommand(getFunctionsCommand(context));
   program2.addCommand(getSecretsCommand(context));
   program2.addCommand(getSiteCommand(context));
   program2.addCommand(getTypesCommand(context));
+  program2.addCommand(getExecCommand(context));
   program2.addCommand(getDevCommand(context), { hidden: true });
   program2.addCommand(getLogsCommand(context), { hidden: true });
   return program2;
@@ -251199,7 +251844,7 @@ var import_detect_agent = __toESM(require_dist5(), 1);
 import { release, type } from "node:os";
 
 // ../../node_modules/posthog-node/dist/extensions/error-tracking/modifiers/module.node.mjs
-import { dirname as dirname14, posix, sep } from "path";
+import { dirname as dirname16, posix, sep } from "path";
 function createModulerModifier() {
   const getModuleFromFileName = createGetModuleFromFilename();
   return async (frames) => {
@@ -251208,7 +251853,7 @@ function createModulerModifier() {
     return frames;
   };
 }
-function createGetModuleFromFilename(basePath = process.argv[1] ? dirname14(process.argv[1]) : process.cwd(), isWindows5 = sep === "\\") {
+function createGetModuleFromFilename(basePath = process.argv[1] ? dirname16(process.argv[1]) : process.cwd(), isWindows5 = sep === "\\") {
   const normalizedBase = isWindows5 ? normalizeWindowsPath2(basePath) : basePath;
   return (filename) => {
     if (!filename)
@@ -253486,14 +254131,14 @@ async function addSourceContext(frames) {
   return frames;
 }
 function getContextLinesFromFile(path19, ranges, output) {
-  return new Promise((resolve9) => {
+  return new Promise((resolve10) => {
     const stream = createReadStream2(path19);
     const lineReaded = createInterface2({
       input: stream
     });
     function destroyStreamAndResolve() {
       stream.destroy();
-      resolve9();
+      resolve10();
     }
     let lineNumber = 0;
     let currentRangeIndex = 0;
@@ -254605,15 +255250,15 @@ class PostHogBackendClient extends PostHogCoreStateless {
       return true;
     if (this.featureFlagsPoller === undefined)
       return false;
-    return new Promise((resolve9) => {
+    return new Promise((resolve10) => {
       const timeout3 = setTimeout(() => {
         cleanup();
-        resolve9(false);
+        resolve10(false);
       }, timeoutMs);
       const cleanup = this._events.on("localEvaluationFlagsLoaded", (count2) => {
         clearTimeout(timeout3);
         cleanup();
-        resolve9(count2 > 0);
+        resolve10(count2 > 0);
       });
     });
   }
@@ -255397,9 +256042,9 @@ function addCommandInfoToErrorReporter(program2, errorReporter) {
   });
 }
 // src/cli/index.ts
-var __dirname4 = dirname15(fileURLToPath6(import.meta.url));
+var __dirname5 = dirname17(fileURLToPath7(import.meta.url));
 async function runCLI(options8) {
-  ensureNpmAssets(join19(__dirname4, "../assets"));
+  ensureNpmAssets(join22(__dirname5, "../assets"));
   const errorReporter = new ErrorReporter;
   errorReporter.registerProcessErrorHandlers();
   const isNonInteractive = !process.stdin.isTTY || !process.stdout.isTTY;
@@ -255432,4 +256077,4 @@ export {
   CLIExitError
 };
 
-//# debugId=3630160A15E12A6F64756E2164756E21
+//# debugId=7CE2464A9D880F1A64756E2164756E21